D627: Memory usage optimization for the compositor.
authorJeroen Bakker <j.bakker@atmind.nl>
Mon, 19 Jan 2015 17:13:26 +0000 (18:13 +0100)
committerJeroen Bakker <j.bakker@atmind.nl>
Mon, 19 Jan 2015 17:17:50 +0000 (18:17 +0100)
The compostor used a fixed size of 4 floats to hold pixel data. this
patch will select size of a pixel based on its type.
It uses 1 float for Value, 3 float for vector and 4 floats for color
data types.

When benchmarking on shots (opening shot of caminandes) we get a
reduction of memory of 30% and a tiny speedup as less data
transformations needs to take place (but these are negligable.

More information of the patch can be found on
https://developer.blender.org/D627 and
http://wiki.blender.org/index.php/Dev:Ref/Proposals/Compositor2014_p1.1_TD

Developers: jbakker & mdewanchand
Thanks for Sergey for his indept review.

48 files changed:
source/blender/compositor/CMakeLists.txt
source/blender/compositor/COM_defines.h
source/blender/compositor/intern/COM_ChannelInfo.cpp [deleted file]
source/blender/compositor/intern/COM_ChannelInfo.h [deleted file]
source/blender/compositor/intern/COM_ExecutionSystem.cpp
source/blender/compositor/intern/COM_MemoryBuffer.cpp
source/blender/compositor/intern/COM_MemoryBuffer.h
source/blender/compositor/intern/COM_MemoryProxy.cpp
source/blender/compositor/intern/COM_MemoryProxy.h
source/blender/compositor/intern/COM_NodeOperationBuilder.cpp
source/blender/compositor/intern/COM_OpenCLDevice.cpp
source/blender/compositor/intern/COM_OpenCLDevice.h
source/blender/compositor/intern/COM_WorkScheduler.cpp
source/blender/compositor/nodes/COM_SocketProxyNode.cpp
source/blender/compositor/nodes/COM_TranslateNode.cpp
source/blender/compositor/operations/COM_AntiAliasOperation.cpp
source/blender/compositor/operations/COM_BokehBlurOperation.cpp
source/blender/compositor/operations/COM_CompositorOperation.cpp
source/blender/compositor/operations/COM_ConvertOperation.cpp
source/blender/compositor/operations/COM_DilateErodeOperation.cpp
source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
source/blender/compositor/operations/COM_FastGaussianBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaXBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianAlphaYBlurOperation.cpp
source/blender/compositor/operations/COM_GaussianBokehBlurOperation.cpp
source/blender/compositor/operations/COM_GlareBaseOperation.cpp
source/blender/compositor/operations/COM_GlareFogGlowOperation.cpp
source/blender/compositor/operations/COM_GlareGhostOperation.cpp
source/blender/compositor/operations/COM_GlareStreaksOperation.cpp
source/blender/compositor/operations/COM_InpaintOperation.cpp
source/blender/compositor/operations/COM_KeyingBlurOperation.cpp
source/blender/compositor/operations/COM_KeyingClipOperation.cpp
source/blender/compositor/operations/COM_MapUVOperation.cpp
source/blender/compositor/operations/COM_NormalizeOperation.cpp
source/blender/compositor/operations/COM_QualityStepHelper.cpp
source/blender/compositor/operations/COM_ReadBufferOperation.cpp
source/blender/compositor/operations/COM_ReadBufferOperation.h
source/blender/compositor/operations/COM_RenderLayersProg.cpp
source/blender/compositor/operations/COM_SetVectorOperation.cpp
source/blender/compositor/operations/COM_SunBeamsOperation.cpp
source/blender/compositor/operations/COM_TextureOperation.cpp
source/blender/compositor/operations/COM_VariableSizeBokehBlurOperation.cpp
source/blender/compositor/operations/COM_VectorBlurOperation.cpp
source/blender/compositor/operations/COM_VectorCurveOperation.cpp
source/blender/compositor/operations/COM_WrapOperation.cpp
source/blender/compositor/operations/COM_WrapOperation.h
source/blender/compositor/operations/COM_WriteBufferOperation.cpp
source/blender/compositor/operations/COM_WriteBufferOperation.h

index 4bcdd4d9e3439104f57050e2a62db546b6e92c95..048c974423f46ad1991fbb39ca2f5753b2e12cce 100644 (file)
@@ -90,8 +90,6 @@ set(SRC
        intern/COM_OpenCLDevice.h
        intern/COM_CompositorContext.cpp
        intern/COM_CompositorContext.h
-       intern/COM_ChannelInfo.cpp
-       intern/COM_ChannelInfo.h
        intern/COM_SingleThreadedOperation.cpp
        intern/COM_SingleThreadedOperation.h
        intern/COM_Debug.cpp
index b60fffc6a22458c592465faa85212add2e587312..9936914d3d88eb1848b19e1c451a8f4c57acc649 100644 (file)
@@ -105,7 +105,9 @@ typedef enum OrderOfChunks {
 
 #define COM_RULE_OF_THIRDS_DIVIDER 100.0f
 
-#define COM_NUMBER_OF_CHANNELS 4
+#define COM_NUM_CHANNELS_VALUE 1
+#define COM_NUM_CHANNELS_VECTOR 3
+#define COM_NUM_CHANNELS_COLOR 4
 
 #define COM_BLUR_BOKEH_PIXELS 512
 
diff --git a/source/blender/compositor/intern/COM_ChannelInfo.cpp b/source/blender/compositor/intern/COM_ChannelInfo.cpp
deleted file mode 100644 (file)
index 557075c..0000000
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * Copyright 2011, Blender Foundation.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contributor: 
- *             Jeroen Bakker 
- *             Monique Dewanchand
- */
-
-#include "COM_ChannelInfo.h"
-#include "COM_defines.h"
-#include <stdio.h>
-
-/**
- * @brief create new ChannelInfo instance and sets the defaults.
- */
-ChannelInfo::ChannelInfo()
-{
-       this->m_number = 0;
-       this->m_premultiplied = true;
-       this->m_type = COM_CT_UNUSED;
-}
diff --git a/source/blender/compositor/intern/COM_ChannelInfo.h b/source/blender/compositor/intern/COM_ChannelInfo.h
deleted file mode 100644 (file)
index ec78e7e..0000000
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * Copyright 2011, Blender Foundation.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- *
- * Contributor: 
- *             Jeroen Bakker 
- *             Monique Dewanchand
- */
-
-#ifndef _COM_ChannelInfo_h
-#define _COM_ChannelInfo_h
-
-#include <vector>
-#include "BKE_text.h"
-#include <string>
-#include "DNA_node_types.h"
-#include "BLI_rect.h"
-
-using namespace std;
-
-/**
- * @brief List of possible channel types
- * @ingroup Model
- */
-typedef enum ChannelType {
-       COM_CT_ColorComponent /** @brief this channel is contains color information. Specific used is determined by channelnumber, and in the future color space */,
-       COM_CT_Alpha /** @brief this channel is contains transparency value */,
-       COM_CT_Value /** @brief this channel is contains a value */,
-       COM_CT_X /** @brief this channel is contains a X value */,
-       COM_CT_Y /** @brief this channel is contains a Y value */,
-       COM_CT_Z /** @brief this channel is contains a Z value */,
-       COM_CT_W /** @brief this channel is contains a W value */,
-       COM_CT_UNUSED /** @brief this channel is unused */
-} ChannelType;
-
-/**
- * @brief ChannelInfo holds information about a channel.
- *
- * Channels are transported from node to node via a NodeLink.
- * ChannelInfo holds specific setting of these channels in order that the to-node of the link
- * Can handle specific logic per channel setting.
- *
- * @note currently this is not used, but a future place to implement color spacing and other things.
- * @ingroup Model
- */
-class ChannelInfo {
-private:
-       /**
-        * @brief the channel number, in the link. [0-3]
-        */
-       int m_number;
-
-       /**
-        * @brief type of channel
-        */
-       ChannelType m_type;
-
-       /**
-        * @brieg Is this value in this channel premultiplied with its alpha
-        * @note only valid if type = ColorComponent;
-        */
-       bool m_premultiplied;
-
-//     /**
-//      * Color space of this value.
-//      * only valid when type = ColorComponent;
-//      */
-//     string colorspacename;
-
-public:
-       /**
-        * @brief creates a new ChannelInfo and set default values
-        */
-       ChannelInfo();
-
-       /**
-        * @brief set the index of this channel in the NodeLink
-        */
-       void setNumber(const int number) { this->m_number = number; }
-
-       /**
-        * @brief get the index of this channel in the NodeLink
-        */
-       const int getNumber() const { return this->m_number; }
-
-       /**
-        * @brief set the type of channel
-        */
-       void setType(const ChannelType type) { this->m_type = type; }
-
-       /**
-        * @brief get the type of channel
-        */
-       const ChannelType getType() const { return this->m_type; }
-
-       /**
-        * @brief set the premultiplicatioin of this channel
-        */
-       void setPremultiplied(const bool premultiplied) { this->m_premultiplied = premultiplied; }
-
-       /**
-        * @brief is this channel premultiplied
-        */
-       const bool isPremultiplied() const { return this->m_premultiplied; }
-};
-
-
-#endif
index 7c08188db90e8a75be858844693aae8cf3b2a28c..0667271f4b18daa6f3d780b7d4d777898c88bf60 100644 (file)
@@ -137,11 +137,15 @@ void ExecutionSystem::execute()
        }
        unsigned int index;
 
+       // First allocale all write buffer
        for (index = 0; index < this->m_operations.size(); index++) {
                NodeOperation *operation = this->m_operations[index];
-               operation->setbNodeTree(this->m_context.getbNodeTree());
-               operation->initExecution();
+               if (operation->isWriteBufferOperation()) {
+                       operation->setbNodeTree(this->m_context.getbNodeTree());
+                       operation->initExecution();
+               }
        }
+       // Connect read buffers to their write buffers
        for (index = 0; index < this->m_operations.size(); index++) {
                NodeOperation *operation = this->m_operations[index];
                if (operation->isReadBufferOperation()) {
@@ -149,6 +153,14 @@ void ExecutionSystem::execute()
                        readOperation->updateMemoryBuffer();
                }
        }
+       // initialize other operations
+       for (index = 0; index < this->m_operations.size(); index++) {
+               NodeOperation *operation = this->m_operations[index];
+               if (!operation->isWriteBufferOperation()) {
+                       operation->setbNodeTree(this->m_context.getbNodeTree());
+                       operation->initExecution();
+               }
+       }
        for (index = 0; index < this->m_groups.size(); index++) {
                ExecutionGroup *executionGroup = this->m_groups[index];
                executionGroup->setChunksize(this->m_context.getChunksize());
index c59ecced93c9e2c9233cb9f4473c507580d511f4..58767960cc850fdbbdb4832bec0a9c88998fd06f 100644 (file)
 using std::min;
 using std::max;
 
+static unsigned int determine_num_channels(DataType datatype) {
+       switch (datatype) {
+       case COM_DT_VALUE:
+               return COM_NUM_CHANNELS_VALUE;
+       case COM_DT_VECTOR:
+               return COM_NUM_CHANNELS_VECTOR;
+       case COM_DT_COLOR:
+       default:
+               return COM_NUM_CHANNELS_COLOR;
+       }
+}
+
 unsigned int MemoryBuffer::determineBufferSize()
 {
        return getWidth() * getHeight();
@@ -34,61 +46,62 @@ unsigned int MemoryBuffer::determineBufferSize()
 
 int MemoryBuffer::getWidth() const
 {
-       return this->m_rect.xmax - this->m_rect.xmin;
+       return this->m_width;
 }
 int MemoryBuffer::getHeight() const
 {
-       return this->m_rect.ymax - this->m_rect.ymin;
+       return this->m_height;
 }
 
 MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, unsigned int chunkNumber, rcti *rect)
 {
        BLI_rcti_init(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
+       this->m_width = BLI_rcti_size_x(&this->m_rect);
+       this->m_height = BLI_rcti_size_y(&this->m_rect);
        this->m_memoryProxy = memoryProxy;
        this->m_chunkNumber = chunkNumber;
-       this->m_buffer = (float *)MEM_mallocN_aligned(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, 16, "COM_MemoryBuffer");
+       this->m_num_channels = determine_num_channels(memoryProxy->getDataType());
+       this->m_buffer = (float *)MEM_mallocN_aligned(sizeof(float) * determineBufferSize() * this->m_num_channels, 16, "COM_MemoryBuffer");
        this->m_state = COM_MB_ALLOCATED;
-       this->m_datatype = COM_DT_COLOR;
-       this->m_chunkWidth = this->m_rect.xmax - this->m_rect.xmin;
+       this->m_datatype = memoryProxy->getDataType();;
 }
 
 MemoryBuffer::MemoryBuffer(MemoryProxy *memoryProxy, rcti *rect)
 {
        BLI_rcti_init(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
+       this->m_width = BLI_rcti_size_x(&this->m_rect);
+       this->m_height = BLI_rcti_size_y(&this->m_rect);
        this->m_memoryProxy = memoryProxy;
        this->m_chunkNumber = -1;
-       this->m_buffer = (float *)MEM_mallocN_aligned(sizeof(float) * determineBufferSize() * COM_NUMBER_OF_CHANNELS, 16, "COM_MemoryBuffer");
+       this->m_num_channels = determine_num_channels(memoryProxy->getDataType());
+       this->m_buffer = (float *)MEM_mallocN_aligned(sizeof(float) * determineBufferSize() * this->m_num_channels, 16, "COM_MemoryBuffer");
+       this->m_state = COM_MB_TEMPORARILY;
+       this->m_datatype = memoryProxy->getDataType();
+}
+MemoryBuffer::MemoryBuffer(DataType dataType, rcti *rect)
+{
+       BLI_rcti_init(&this->m_rect, rect->xmin, rect->xmax, rect->ymin, rect->ymax);
+       this->m_width = BLI_rcti_size_x(&this->m_rect);
+       this->m_height = BLI_rcti_size_y(&this->m_rect);
+       this->m_height = this->m_rect.ymax - this->m_rect.ymin;
+       this->m_memoryProxy = NULL;
+       this->m_chunkNumber = -1;
+       this->m_num_channels = determine_num_channels(dataType);
+       this->m_buffer = (float *)MEM_mallocN_aligned(sizeof(float) * determineBufferSize() * this->m_num_channels, 16, "COM_MemoryBuffer");
        this->m_state = COM_MB_TEMPORARILY;
-       this->m_datatype = COM_DT_COLOR;
-       this->m_chunkWidth = this->m_rect.xmax - this->m_rect.xmin;
+       this->m_datatype = dataType;
 }
 MemoryBuffer *MemoryBuffer::duplicate()
 {
        MemoryBuffer *result = new MemoryBuffer(this->m_memoryProxy, &this->m_rect);
-       memcpy(result->m_buffer, this->m_buffer, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+       memcpy(result->m_buffer, this->m_buffer, this->determineBufferSize() * this->m_num_channels * sizeof(float));
        return result;
 }
 void MemoryBuffer::clear()
 {
-       memset(this->m_buffer, 0, this->determineBufferSize() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+       memset(this->m_buffer, 0, this->determineBufferSize() * this->m_num_channels * sizeof(float));
 }
 
-float *MemoryBuffer::convertToValueBuffer()
-{
-       const unsigned int size = this->determineBufferSize();
-       unsigned int i;
-
-       float *result = (float *)MEM_mallocN(sizeof(float) * size, __func__);
-
-       const float *fp_src = this->m_buffer;
-       float       *fp_dst = result;
-
-       for (i = 0; i < size; i++, fp_dst++, fp_src += COM_NUMBER_OF_CHANNELS) {
-               *fp_dst = *fp_src;
-       }
-
-       return result;
-}
 
 float MemoryBuffer::getMaximumValue()
 {
@@ -98,7 +111,7 @@ float MemoryBuffer::getMaximumValue()
 
        const float *fp_src = this->m_buffer;
 
-       for (i = 0; i < size; i++, fp_src += COM_NUMBER_OF_CHANNELS) {
+       for (i = 0; i < size; i++, fp_src += this->m_num_channels) {
                float value = *fp_src;
                if (value > result) {
                        result = value;
@@ -116,7 +129,7 @@ float MemoryBuffer::getMaximumValue(rcti *rect)
        BLI_rcti_isect(rect, &this->m_rect, &rect_clamp);
 
        if (!BLI_rcti_is_empty(&rect_clamp)) {
-               MemoryBuffer *temp = new MemoryBuffer(NULL, &rect_clamp);
+               MemoryBuffer *temp = new MemoryBuffer(this->m_datatype, &rect_clamp);
                temp->copyContentFrom(this);
                float result = temp->getMaximumValue();
                delete temp;
@@ -152,9 +165,9 @@ void MemoryBuffer::copyContentFrom(MemoryBuffer *otherBuffer)
 
 
        for (otherY = minY; otherY < maxY; otherY++) {
-               otherOffset = ((otherY - otherBuffer->m_rect.ymin) * otherBuffer->m_chunkWidth + minX - otherBuffer->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
-               offset = ((otherY - this->m_rect.ymin) * this->m_chunkWidth + minX - this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
-               memcpy(&this->m_buffer[offset], &otherBuffer->m_buffer[otherOffset], (maxX - minX) * COM_NUMBER_OF_CHANNELS * sizeof(float));
+               otherOffset = ((otherY - otherBuffer->m_rect.ymin) * otherBuffer->m_width + minX - otherBuffer->m_rect.xmin) * this->m_num_channels;
+               offset = ((otherY - this->m_rect.ymin) * this->m_width + minX - this->m_rect.xmin) * this->m_num_channels;
+               memcpy(&this->m_buffer[offset], &otherBuffer->m_buffer[otherOffset], (maxX - minX) * this->m_num_channels * sizeof(float));
        }
 }
 
@@ -163,9 +176,8 @@ 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 - this->m_rect.ymin) + x - this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
-               copy_v4_v4(&this->m_buffer[offset], color);
-       }
+               const int offset = (this->m_width * (y - this->m_rect.ymin) + x - this->m_rect.xmin) * this->m_num_channels;
+               memcpy(&this->m_buffer[offset], color, sizeof(float)*this->m_num_channels);     }
 }
 
 void MemoryBuffer::addPixel(int x, int y, const float color[4])
@@ -173,8 +185,12 @@ 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 - this->m_rect.ymin) + x - this->m_rect.xmin) * COM_NUMBER_OF_CHANNELS;
-               add_v4_v4(&this->m_buffer[offset], color);
+               const int offset = (this->m_width * (y - this->m_rect.ymin) + x - this->m_rect.xmin) * this->m_num_channels;
+                float *dst = &this->m_buffer[offset];
+                const float *src = color;
+                for (int i = 0; i < this->m_num_channels ; i++, dst++, src++) {
+                        *dst += *src;
+                }
        }
 }
 
@@ -208,8 +224,9 @@ static void read_ewa_pixel_sampled(void *userdata, int x, int y, float result[4]
        }
 }
 
-void MemoryBuffer::readEWA(float result[4], const float uv[2], const float derivatives[2][2], PixelSampler sampler)
+void MemoryBuffer::readEWA(float *result, const float uv[2], const float derivatives[2][2], PixelSampler sampler)
 {
+       BLI_assert(this->m_datatype==COM_DT_COLOR);
        ReadEWAData data;
        data.buffer = this;
        data.sampler = sampler;
index d6ef9cd673ee1066cfc6bb1486ed4d78b2dc8a26..70b4dec2bed09a1e4f99a9349c13b622025067c0 100644 (file)
@@ -82,11 +82,6 @@ private:
         */
        unsigned int m_chunkNumber;
        
-       /**
-        * @brief width of the chunk
-        */
-       unsigned int m_chunkWidth;
-       
        /**
         * @brief state of the buffer
         */
@@ -97,6 +92,15 @@ private:
         */
        float *m_buffer;
 
+       /**
+        * @brief the number of channels of a single value in the buffer.
+        * For value buffers this is 1, vector 3 and color 4
+        */
+       unsigned int m_num_channels;
+
+       int m_width;
+       int m_height;
+
 public:
        /**
         * @brief construct new MemoryBuffer for a chunk
@@ -107,7 +111,12 @@ public:
         * @brief construct new temporarily MemoryBuffer for an area
         */
        MemoryBuffer(MemoryProxy *memoryProxy, rcti *rect);
-       
+
+       /**
+        * @brief construct new temporarily MemoryBuffer for an area
+        */
+       MemoryBuffer(DataType datatype, rcti *rect);
+
        /**
         * @brief destructor
         */
@@ -117,7 +126,9 @@ public:
         * @brief read the ChunkNumber of this MemoryBuffer
         */
        unsigned int getChunkNumber() { return this->m_chunkNumber; }
-       
+
+       unsigned int get_num_channels() { return this->m_num_channels; }
+
        /**
         * @brief get the data of this MemoryBuffer
         * @note buffer should already be available in memory
@@ -134,8 +145,8 @@ public:
        
        inline void wrap_pixel(int &x, int &y, MemoryBufferExtend extend_x, MemoryBufferExtend extend_y)
        {
-               int w = m_rect.xmax - m_rect.xmin;
-               int h = m_rect.ymax - m_rect.ymin;
+               int w = this->m_width;
+               int h = this->m_height;
                x = x - m_rect.xmin;
                y = y - m_rect.ymin;
                
@@ -164,7 +175,39 @@ public:
                }
        }
        
-       inline void read(float result[4], int x, int y,
+       inline void wrap_pixel(float &x, float &y, MemoryBufferExtend extend_x, MemoryBufferExtend extend_y)
+       {
+               float w = (float)this->m_width;
+               float h = (float)this->m_height;
+               x = x - m_rect.xmin;
+               y = y - m_rect.ymin;
+
+               switch (extend_x) {
+                       case COM_MB_CLIP:
+                               break;
+                       case COM_MB_EXTEND:
+                               if (x < 0) x = 0.0f;
+                               if (x >= w) x = w;
+                               break;
+                       case COM_MB_REPEAT:
+                               x = fmodf(x, w);
+                               break;
+               }
+
+               switch (extend_y) {
+                       case COM_MB_CLIP:
+                               break;
+                       case COM_MB_EXTEND:
+                               if (y < 0) y = 0.0f;
+                               if (y >= h) y = h;
+                               break;
+                       case COM_MB_REPEAT:
+                               y = fmodf(y, h);
+                               break;
+               }
+       }
+
+       inline void read(float *result, int x, int y,
                         MemoryBufferExtend extend_x = COM_MB_CLIP,
                         MemoryBufferExtend extend_y = COM_MB_CLIP)
        {
@@ -172,81 +215,54 @@ public:
                bool clip_y = (extend_y == COM_MB_CLIP && (y < m_rect.ymin || y >= m_rect.ymax));
                if (clip_x || clip_y) {
                        /* clip result outside rect is zero */
-                       zero_v4(result);
+                       memset(result, 0, this->m_num_channels*sizeof(float));
                }
                else {
-                       wrap_pixel(x, y, extend_x, extend_y);
-                       const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
-                       copy_v4_v4(result, &this->m_buffer[offset]);
+                       int u = x;
+                       int v = y;
+                       this->wrap_pixel(u, v, extend_x, extend_y);
+                       const int offset = (this->m_width * y + x) * this->m_num_channels;
+                       float* buffer = &this->m_buffer[offset];
+                       memcpy(result, buffer, sizeof(float)*this->m_num_channels);
                }
        }
 
-       inline void readNoCheck(float result[4], int x, int y,
+       inline void readNoCheck(float *result, int x, int y,
                                MemoryBufferExtend extend_x = COM_MB_CLIP,
                                MemoryBufferExtend extend_y = COM_MB_CLIP)
        {
-               wrap_pixel(x, y, extend_x, extend_y);
-               const int offset = (this->m_chunkWidth * y + x) * COM_NUMBER_OF_CHANNELS;
+               int u = x;
+               int v = y;
 
-               BLI_assert(offset >= 0);
-               BLI_assert(offset < this->determineBufferSize() * COM_NUMBER_OF_CHANNELS);
-               BLI_assert(!(extend_x == COM_MB_CLIP && (x < m_rect.xmin || x >= m_rect.xmax)) &&
-                          !(extend_y == COM_MB_CLIP && (y < m_rect.ymin || y >= m_rect.ymax)));
+               this->wrap_pixel(u, v, extend_x, extend_y);
+               const int offset = (this->m_width * v + u) * this->m_num_channels;
 
+               BLI_assert(offset >= 0);
+               BLI_assert(offset < this->determineBufferSize() * this->m_num_channels);
+               BLI_assert(!(extend_x == COM_MB_CLIP && (u < m_rect.xmin || u >= m_rect.xmax)) &&
+                                  !(extend_y == COM_MB_CLIP && (v < m_rect.ymin || v >= m_rect.ymax)));
 #if 0
                /* always true */
                BLI_assert((int)(MEM_allocN_len(this->m_buffer) / sizeof(*this->m_buffer)) ==
                           (int)(this->determineBufferSize() * COM_NUMBER_OF_CHANNELS));
 #endif
-
-               copy_v4_v4(result, &this->m_buffer[offset]);
+               float* buffer = &this->m_buffer[offset];
+               memcpy(result, buffer, sizeof(float)*this->m_num_channels);
        }
        
        void writePixel(int x, int y, const float color[4]);
        void addPixel(int x, int y, const float color[4]);
-       inline void readBilinear(float result[4], float x, float y,
+       inline void readBilinear(float *result, float x, float y,
                                 MemoryBufferExtend extend_x = COM_MB_CLIP,
                                 MemoryBufferExtend extend_y = COM_MB_CLIP)
        {
-               int x1 = floor(x);
-               int y1 = floor(y);
-               int x2 = x1 + 1;
-               int y2 = y1 + 1;
-               wrap_pixel(x1, y1, extend_x, extend_y);
-               wrap_pixel(x2, y2, extend_x, extend_y);
-
-               float valuex = x - x1;
-               float valuey = y - y1;
-               float mvaluex = 1.0f - valuex;
-               float mvaluey = 1.0f - valuey;
-
-               float color1[4];
-               float color2[4];
-               float color3[4];
-               float color4[4];
-
-               read(color1, x1, y1);
-               read(color2, x1, y2);
-               read(color3, x2, y1);
-               read(color4, x2, y2);
-
-               color1[0] = color1[0] * mvaluey + color2[0] * valuey;
-               color1[1] = color1[1] * mvaluey + color2[1] * valuey;
-               color1[2] = color1[2] * mvaluey + color2[2] * valuey;
-               color1[3] = color1[3] * mvaluey + color2[3] * valuey;
-
-               color3[0] = color3[0] * mvaluey + color4[0] * valuey;
-               color3[1] = color3[1] * mvaluey + color4[1] * valuey;
-               color3[2] = color3[2] * mvaluey + color4[2] * valuey;
-               color3[3] = color3[3] * mvaluey + color4[3] * valuey;
-
-               result[0] = color1[0] * mvaluex + color3[0] * valuex;
-               result[1] = color1[1] * mvaluex + color3[1] * valuex;
-               result[2] = color1[2] * mvaluex + color3[2] * valuex;
-               result[3] = color1[3] * mvaluex + color3[3] * valuex;
+               float u = x;
+               float v = y;
+               this->wrap_pixel(u, v, extend_x, extend_y);
+               BLI_bilinear_interpolation_fl(this->m_buffer, result, this->m_width, this->m_height, this->m_num_channels, u, v);
        }
 
-       void readEWA(float result[4], const float uv[2], const float derivatives[2][2], PixelSampler sampler);
+       void readEWA(float *result, const float uv[2], const float derivatives[2][2], PixelSampler sampler);
        
        /**
         * @brief is this MemoryBuffer a temporarily buffer (based on an area, not on a chunk)
@@ -284,7 +300,6 @@ public:
        
        MemoryBuffer *duplicate();
        
-       float *convertToValueBuffer();
        float getMaximumValue();
        float getMaximumValue(rcti *rect);
 private:
index 90ca0baea06e5fbe256af689ba1adc51bb6649ad..1df3e59db623e726a1d37f992eea519d0a5ceffa 100644 (file)
 #include "COM_MemoryProxy.h"
 
 
-MemoryProxy::MemoryProxy()
+MemoryProxy::MemoryProxy(DataType datatype)
 {
        this->m_writeBufferOperation = NULL;
        this->m_executor = NULL;
+       this->m_datatype = datatype;
 }
 
 void MemoryProxy::allocate(unsigned int width, unsigned int height)
index 233b035a2d70cf7abc6c0f6c21b0a0f628546aac..b332852088bb470883c311f69d92e6b1d10a2df1 100644 (file)
@@ -63,8 +63,13 @@ private:
         */
        MemoryBuffer *m_buffer;
 
+       /**
+        * @brief datatype of this MemoryProxy
+        */
+       DataType m_datatype;
+
 public:
-       MemoryProxy();
+       MemoryProxy(DataType type);
        
        /**
         * @brief set the ExecutionGroup that can be scheduled to calculate a certain chunk.
@@ -104,6 +109,8 @@ public:
         */
        inline MemoryBuffer *getBuffer() { return this->m_buffer; }
 
+       inline DataType getDataType() { return this->m_datatype; }
+
 #ifdef WITH_CXX_GUARDEDALLOC
        MEM_CXX_CLASS_ALLOC_FUNCS("COM:MemoryProxy")
 #endif
index fb5bc8fcd9b4ce9add0bbb22e0c87236ae8fc1ba..74c05c3e62ed8cf0040b6cc43f3a2e859c13335d 100644 (file)
@@ -476,7 +476,7 @@ void NodeOperationBuilder::add_input_buffers(NodeOperation *operation, NodeOpera
        /* check of other end already has write operation, otherwise add a new one */
        WriteBufferOperation *writeoperation = find_attached_write_buffer_operation(output);
        if (!writeoperation) {
-               writeoperation = new WriteBufferOperation();
+               writeoperation = new WriteBufferOperation(output->getDataType());
                writeoperation->setbNodeTree(m_context->getbNodeTree());
                addOperation(writeoperation);
                
@@ -486,7 +486,7 @@ void NodeOperationBuilder::add_input_buffers(NodeOperation *operation, NodeOpera
        }
        
        /* add readbuffer op for the input */
-       ReadBufferOperation *readoperation = new ReadBufferOperation();
+       ReadBufferOperation *readoperation = new ReadBufferOperation(output->getDataType());
        readoperation->setMemoryProxy(writeoperation->getMemoryProxy());
        this->addOperation(readoperation);
        
@@ -519,7 +519,7 @@ void NodeOperationBuilder::add_output_buffers(NodeOperation *operation, NodeOper
        
        /* if no write buffer operation exists yet, create a new one */
        if (!writeOperation) {
-               writeOperation = new WriteBufferOperation();
+               writeOperation = new WriteBufferOperation(operation->getOutputSocket()->getDataType());
                writeOperation->setbNodeTree(m_context->getbNodeTree());
                addOperation(writeOperation);
                
@@ -534,7 +534,7 @@ void NodeOperationBuilder::add_output_buffers(NodeOperation *operation, NodeOper
                if (&target->getOperation() == writeOperation)
                        continue; /* skip existing write op links */
                
-               ReadBufferOperation *readoperation = new ReadBufferOperation();
+               ReadBufferOperation *readoperation = new ReadBufferOperation(operation->getOutputSocket()->getDataType());
                readoperation->setMemoryProxy(writeOperation->getMemoryProxy());
                addOperation(readoperation);
                
index c5b663d2aef10fe4ae12d1613b5f3e48bfa23c67..7fc4fd38abd3f84ce80ee201f79a5cd5fea7852c 100644 (file)
 #include "COM_WorkScheduler.h"
 
 typedef enum COM_VendorID  {NVIDIA = 0x10DE, AMD = 0x1002} COM_VendorID;
+const cl_image_format IMAGE_FORMAT_COLOR = {
+       CL_RGBA,
+       CL_FLOAT
+};
+const cl_image_format IMAGE_FORMAT_VECTOR = {
+       CL_RGB,
+       CL_FLOAT
+};
+const cl_image_format IMAGE_FORMAT_VALUE = {
+       CL_R,
+       CL_FLOAT
+};
 
 OpenCLDevice::OpenCLDevice(cl_context context, cl_device_id device, cl_program program, cl_int vendorId)
 {
@@ -72,6 +84,21 @@ cl_mem OpenCLDevice::COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel,
        return COM_clAttachMemoryBufferToKernelParameter(kernel, parameterIndex, offsetIndex, cleanup, inputMemoryBuffers, (ReadBufferOperation *)reader);
 }
 
+const cl_image_format* OpenCLDevice::determineImageFormat(MemoryBuffer *memoryBuffer)
+{
+       const cl_image_format *imageFormat;
+       int num_channels = memoryBuffer->get_num_channels();
+       if (num_channels == 1) {
+               imageFormat = &IMAGE_FORMAT_VALUE;
+       } else if (num_channels == 3) {
+               imageFormat = &IMAGE_FORMAT_VECTOR;
+       } else {
+               imageFormat = &IMAGE_FORMAT_COLOR;
+       }
+
+       return imageFormat;
+}
+
 cl_mem OpenCLDevice::COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel, int parameterIndex, int offsetIndex,
                                                                list<cl_mem> *cleanup, MemoryBuffer **inputMemoryBuffers,
                                                                ReadBufferOperation *reader)
@@ -80,12 +107,9 @@ cl_mem OpenCLDevice::COM_clAttachMemoryBufferToKernelParameter(cl_kernel kernel,
        
        MemoryBuffer *result = reader->getInputMemoryBuffer(inputMemoryBuffers);
 
-       const cl_image_format imageFormat = {
-               CL_RGBA,
-               CL_FLOAT
-       };
+       const cl_image_format *imageFormat = determineImageFormat(result);
 
-       cl_mem clBuffer = clCreateImage2D(this->m_context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, &imageFormat, result->getWidth(),
+       cl_mem clBuffer = clCreateImage2D(this->m_context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR, imageFormat, result->getWidth(),
                                          result->getHeight(), 0, result->getBuffer(), &error);
 
        if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
index 94df2f2b44c880ff41af0e85ffb1ff89ae8fba62..f8a8841ef475da5169adf0a67acd4050ed197d55 100644 (file)
@@ -94,6 +94,12 @@ public:
         */
        void execute(WorkPackage *work);
 
+       /**
+       * @brief determine an image format
+       * @param memorybuffer
+       */
+       static const cl_image_format* determineImageFormat(MemoryBuffer *memoryBuffer);
+
        cl_context getContext() { return this->m_context; }
 
        cl_command_queue getQueue() { return this->m_queue; }
index e1016731c7f253b4a1209c91568c4b1001d76fad..8445dee5ae4ce0ad3c444dd4330a869c4a26b0c0 100644 (file)
@@ -196,7 +196,7 @@ void WorkScheduler::schedule(ExecutionGroup *group, int chunkNumber)
                BLI_thread_queue_push(g_cpuqueue, package);
        }
 #else
-       BLI_thread_queue_push(cpuqueue, package);
+       BLI_thread_queue_push(g_cpuqueue, package);
 #endif
 #endif
 }
index 48c8acfc6a1109ed8ddf052030e253473df3fcba..17b00af16d8bce2f44a4f2cafe17a782850c0d40 100644 (file)
@@ -73,8 +73,9 @@ void SocketBufferNode::convertToOperations(NodeConverter &converter, const Compo
        NodeOutput *output = this->getOutputSocket(0);
        NodeInput *input = this->getInputSocket(0);
        
-       WriteBufferOperation *writeOperation = new WriteBufferOperation();
-       ReadBufferOperation *readOperation = new ReadBufferOperation();
+       DataType datatype = output->getDataType();
+       WriteBufferOperation *writeOperation = new WriteBufferOperation(datatype);
+       ReadBufferOperation *readOperation = new ReadBufferOperation(datatype);
        readOperation->setMemoryProxy(writeOperation->getMemoryProxy());
        converter.addOperation(writeOperation);
        converter.addOperation(readOperation);
index 990cbe19be2daa4916bd3a2f4991cc21e40e9690..04dc1d435d3eaeaee23a040cfb219f67b870f416 100644 (file)
@@ -57,8 +57,8 @@ void TranslateNode::convertToOperations(NodeConverter &converter, const Composit
        converter.mapOutputSocket(outputSocket, operation->getOutputSocket(0));
        
        if (data->wrap_axis) {
-               WriteBufferOperation *writeOperation = new WriteBufferOperation();
-               WrapOperation *wrapOperation = new WrapOperation();
+               WriteBufferOperation *writeOperation = new WriteBufferOperation(COM_DT_COLOR);
+               WrapOperation *wrapOperation = new WrapOperation(COM_DT_COLOR);
                wrapOperation->setMemoryProxy(writeOperation->getMemoryProxy());
                wrapOperation->setWrapping(data->wrap_axis);
                
index 995c61589cc38dda654e7437e96e0d913f3a6299..b25e22814679a548692f5d5c908a4dce3f00846f 100644 (file)
@@ -95,7 +95,7 @@ void *AntiAliasOperation::initializeTileData(rcti *rect)
                float *input = tile->getBuffer();
                char *valuebuffer = (char *)MEM_mallocN(sizeof(char) * size, __func__);
                for (int i = 0; i < size; i++) {
-                       float in = input[i * COM_NUMBER_OF_CHANNELS];
+                       float in = input[i];
                        valuebuffer[i] = FTOCHAR(in);
                }
                antialias_tagbuf(tile->getWidth(), tile->getHeight(), valuebuffer);
index f5bca5371e6024dc0aa2d83842f7e0fcc94a1d72..22f6fc33a0da59c3bf8b08f3197aa37109a61fe1 100644 (file)
@@ -110,11 +110,11 @@ void BokehBlurOperation::executePixel(float output[4], int x, int y, void *data)
 
 
                int step = getStep();
-               int offsetadd = getOffsetAdd();
+               int offsetadd = getOffsetAdd() * COM_NUM_CHANNELS_COLOR;
 
                float m = this->m_bokehDimension / pixelSize;
                for (int ny = miny; ny < maxy; ny += step) {
-                       int bufferindex = ((minx - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth);
+                       int bufferindex = ((minx - bufferstartx) * COM_NUM_CHANNELS_COLOR) + ((ny - bufferstarty) * COM_NUM_CHANNELS_COLOR * bufferwidth);
                        for (int nx = minx; nx < maxx; nx += step) {
                                float u = this->m_bokehMidX - (nx - x) * m;
                                float v = this->m_bokehMidY - (ny - y) * m;
index ef331a50dfd37ba8d7dbf49c32a66e8b12a50b59..e3438bcbd1529b2348921bf9a67386f7d39abcdd 100644 (file)
@@ -138,7 +138,7 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int tileNumber)
        int y2 = rect->ymax;
        int offset = (y1 * this->getWidth() + x1);
        int add = (this->getWidth() - (x2 - x1));
-       int offset4 = offset * COM_NUMBER_OF_CHANNELS;
+       int offset4 = offset * COM_NUM_CHANNELS_COLOR;
        int x;
        int y;
        bool breaked = false;
@@ -196,14 +196,14 @@ void CompositorOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 
                        this->m_depthInput->readSampled(color, input_x, input_y, COM_PS_NEAREST);
                        zbuffer[offset] = color[0];
-                       offset4 += COM_NUMBER_OF_CHANNELS;
+                       offset4 += COM_NUM_CHANNELS_COLOR;
                        offset++;
                        if (isBreaked()) {
                                breaked = true;
                        }
                }
                offset += add;
-               offset4 += add * COM_NUMBER_OF_CHANNELS;
+               offset4 += add * COM_NUM_CHANNELS_COLOR;
        }
 }
 
index 1445b78552f7054da62dddf2e8301bb61147cd8d..977586acb603b49580a07f6e27ddd0bf21d0bf49 100644 (file)
@@ -49,9 +49,9 @@ ConvertValueToColorOperation::ConvertValueToColorOperation() : ConvertBaseOperat
 
 void ConvertValueToColorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       float inputValue[4];
-       this->m_inputOperation->readSampled(inputValue, x, y, sampler);
-       output[0] = output[1] = output[2] = inputValue[0];
+       float value;
+       this->m_inputOperation->readSampled(&value, x, y, sampler);
+       output[0] = output[1] = output[2] = value;
        output[3] = 1.0f;
 }
 
@@ -98,8 +98,9 @@ ConvertColorToVectorOperation::ConvertColorToVectorOperation() : ConvertBaseOper
 
 void ConvertColorToVectorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       this->m_inputOperation->readSampled(output, x, y, sampler);
-}
+       float color[4];
+       this->m_inputOperation->readSampled(color, x, y, sampler);
+       copy_v3_v3(output, color);}
 
 
 /* ******** Value to Vector ******** */
@@ -112,12 +113,9 @@ ConvertValueToVectorOperation::ConvertValueToVectorOperation() : ConvertBaseOper
 
 void ConvertValueToVectorOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       float input[4];
-       this->m_inputOperation->readSampled(input, x, y, sampler);
-       output[0] = input[0];
-       output[1] = input[0];
-       output[2] = input[0];
-       output[3] = 0.0f;
+       float value;
+       this->m_inputOperation->readSampled(&value, x, y, sampler);
+       output[0] = output[1] = output[2] = value;
 }
 
 
index cbf4ce693d922a1e6194d52628506093e957f804..cee39994aed0a4a955a4a870dcf7f06f50891b94 100644 (file)
@@ -72,7 +72,7 @@ void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y,
        const float inset = this->m_inset;
        float mindist = rd * 2;
 
-       MemoryBuffer *inputBuffer = (MemoryBuffer *)data;
+       MemoryBuffer *inputBuffer = (MemoryBuffer*)data;
        float *buffer = inputBuffer->getBuffer();
        rcti *rect = inputBuffer->getRect();
        const int minx = max(x - this->m_scope, rect->xmin);
@@ -82,18 +82,18 @@ void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y,
        const int bufferWidth = BLI_rcti_size_x(rect);
        int offset;
 
-       this->m_inputProgram->read(inputValue, x, y, NULL);
+       inputBuffer->read(inputValue, x, y);
        if (inputValue[0] > sw) {
                for (int yi = miny; yi < maxy; yi++) {
                        const float dy = yi - y;
-                       offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin)) * 4;
+                       offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin));
                        for (int xi = minx; xi < maxx; xi++) {
                                if (buffer[offset] < sw) {
                                        const float dx = xi - x;
                                        const float dis = dx * dx + dy * dy;
                                        mindist = min(mindist, dis);
                                }
-                               offset += 4;
+                               offset ++;
                        }
                }
                pixelvalue = -sqrtf(mindist);
@@ -101,15 +101,14 @@ void DilateErodeThresholdOperation::executePixel(float output[4], int x, int y,
        else {
                for (int yi = miny; yi < maxy; yi++) {
                        const float dy = yi - y;
-                       offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin)) * 4;
+                       offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin));
                        for (int xi = minx; xi < maxx; xi++) {
                                if (buffer[offset] > sw) {
                                        const float dx = xi - x;
                                        const float dis = dx * dx + dy * dy;
                                        mindist = min(mindist, dis);
                                }
-                               offset += 4;
-
+                               offset ++;
                        }
                }
                pixelvalue = sqrtf(mindist);
@@ -206,14 +205,14 @@ void DilateDistanceOperation::executePixel(float output[4], int x, int y, void *
 
        for (int yi = miny; yi < maxy; yi++) {
                const float dy = yi - y;
-               offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin)) * 4;
+               offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin));
                for (int xi = minx; xi < maxx; xi++) {
                        const float dx = xi - x;
                        const float dis = dx * dx + dy * dy;
                        if (dis <= mindist) {
                                value = max(buffer[offset], value);
                        }
-                       offset += 4;
+                       offset ++;
                }
        }
        output[0] = value;
@@ -280,14 +279,14 @@ void ErodeDistanceOperation::executePixel(float output[4], int x, int y, void *d
 
        for (int yi = miny; yi < maxy; yi++) {
                const float dy = yi - y;
-               offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin)) * 4;
+               offset = ((yi - rect->ymin) * bufferWidth + (minx - rect->xmin));
                for (int xi = minx; xi < maxx; xi++) {
                        const float dx = xi - x;
                        const float dis = dx * dx + dy * dy;
                        if (dis <= mindist) {
                                value = min(buffer[offset], value);
                        }
-                       offset += 4;
+                       offset ++;
                }
        }
        output[0] = value;
@@ -383,7 +382,7 @@ void *DilateStepOperation::initializeTileData(rcti *rect)
                        buf[x] = -FLT_MAX;
                }
                for (x = xmin; x < xmax; ++x) {
-                       buf[x - rect->xmin + window - 1] = buffer[4 * (y * width + x)];
+                       buf[x - rect->xmin + window - 1] = buffer[(y * width + x)];
                }
 
                for (i = 0; i < (bwidth + 3 * half_window) / window; i++) {
@@ -510,7 +509,7 @@ void *ErodeStepOperation::initializeTileData(rcti *rect)
                        buf[x] = FLT_MAX;
                }
                for (x = xmin; x < xmax; ++x) {
-                       buf[x - rect->xmin + window - 1] = buffer[4 * (y * width + x)];
+                       buf[x - rect->xmin + window - 1] = buffer[(y * width + x)];
                }
 
                for (i = 0; i < (bwidth + 3 * half_window) / window; i++) {
index 5006720f09188707bcaa24ca223ba9dcae963055..234a61a4c417362284cf7f4b6bc66a1beabfa766 100644 (file)
@@ -1270,11 +1270,9 @@ void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect)
                MemoryBuffer *innerMask = (MemoryBuffer *)this->m_inputInnerMask->initializeTileData(rect);
                MemoryBuffer *outerMask = (MemoryBuffer *)this->m_inputOuterMask->initializeTileData(rect);
                float *data = (float *)MEM_mallocN(sizeof(float) * this->getWidth() * this->getHeight(), __func__);
-               float *imask = innerMask->convertToValueBuffer();
-               float *omask = outerMask->convertToValueBuffer();
+               float *imask = innerMask->getBuffer();
+               float *omask = outerMask->getBuffer();
                doDoubleEdgeMask(imask, omask, data);
-               MEM_freeN(imask);
-               MEM_freeN(omask);
                this->m_cachedInstance = data;
        }
        unlockMutex();
index 705a8c073815518bd59fbaebb75d5013722b06c6..08f520e42710cda2a43a8eb31c75575a112ff960 100644 (file)
@@ -92,16 +92,16 @@ void *FastGaussianBlurOperation::initializeTileData(rcti *rect)
                this->m_sy = this->m_data.sizey * this->m_size / 2.0f;
                
                if ((this->m_sx == this->m_sy) && (this->m_sx > 0.f)) {
-                       for (c = 0; c < COM_NUMBER_OF_CHANNELS; ++c)
+                       for (c = 0; c < COM_NUM_CHANNELS_COLOR; ++c)
                                IIR_gauss(copy, this->m_sx, c, 3);
                }
                else {
                        if (this->m_sx > 0.0f) {
-                               for (c = 0; c < COM_NUMBER_OF_CHANNELS; ++c)
+                               for (c = 0; c < COM_NUM_CHANNELS_COLOR; ++c)
                                        IIR_gauss(copy, this->m_sx, c, 1);
                        }
                        if (this->m_sy > 0.0f) {
-                               for (c = 0; c < COM_NUMBER_OF_CHANNELS; ++c)
+                               for (c = 0; c < COM_NUM_CHANNELS_COLOR; ++c)
                                        IIR_gauss(copy, this->m_sy, c, 2);
                        }
                }
@@ -120,6 +120,7 @@ void FastGaussianBlurOperation::IIR_gauss(MemoryBuffer *src, float sigma, unsign
        unsigned int x, y, sz;
        unsigned int i;
        float *buffer = src->getBuffer();
+       const unsigned int num_channels = src->get_num_channels();
        
        // <0.5 not valid, though can have a possibly useful sort of sharpening effect
        if (sigma < 0.5f) return;
@@ -198,31 +199,31 @@ void FastGaussianBlurOperation::IIR_gauss(MemoryBuffer *src, float sigma, unsign
                int offset;
                for (y = 0; y < src_height; ++y) {
                        const int yx = y * src_width;
-                       offset = yx * COM_NUMBER_OF_CHANNELS + chan;
+                       offset = yx * num_channels + chan;
                        for (x = 0; x < src_width; ++x) {
                                X[x] = buffer[offset];
-                               offset += COM_NUMBER_OF_CHANNELS;
+                               offset += num_channels;
                        }
                        YVV(src_width);
-                       offset = yx * COM_NUMBER_OF_CHANNELS + chan;
+                       offset = yx * num_channels + chan;
                        for (x = 0; x < src_width; ++x) {
                                buffer[offset] = Y[x];
-                               offset += COM_NUMBER_OF_CHANNELS;
+                               offset += num_channels;
                        }
                }
        }
        if (xy & 2) {   // V
                int offset;
-               const int add = src_width * COM_NUMBER_OF_CHANNELS;
+               const int add = src_width * num_channels;
 
                for (x = 0; x < src_width; ++x) {
-                       offset = x * COM_NUMBER_OF_CHANNELS + chan;
+                       offset = x * num_channels + chan;
                        for (y = 0; y < src_height; ++y) {
                                X[y] = buffer[offset];
                                offset += add;
                        }
                        YVV(src_height);
-                       offset = x * COM_NUMBER_OF_CHANNELS + chan;
+                       offset = x * num_channels + chan;
                        for (y = 0; y < src_height; ++y) {
                                buffer[offset] = Y[y];
                                offset += add;
@@ -298,7 +299,7 @@ void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect)
                if (this->m_overlay == FAST_GAUSS_OVERLAY_MIN) {
                        float *src = newBuf->getBuffer();
                        float *dst = copy->getBuffer();
-                       for (int i = copy->getWidth() * copy->getHeight(); i != 0; i--, src += COM_NUMBER_OF_CHANNELS, dst += COM_NUMBER_OF_CHANNELS) {
+                       for (int i = copy->getWidth() * copy->getHeight(); i != 0; i--, src += COM_NUM_CHANNELS_VALUE, dst += COM_NUM_CHANNELS_VALUE) {
                                if (*src < *dst) {
                                        *dst = *src;
                                }
@@ -307,7 +308,7 @@ void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect)
                else if (this->m_overlay == FAST_GAUSS_OVERLAY_MAX) {
                        float *src = newBuf->getBuffer();
                        float *dst = copy->getBuffer();
-                       for (int i = copy->getWidth() * copy->getHeight(); i != 0; i--, src += COM_NUMBER_OF_CHANNELS, dst += COM_NUMBER_OF_CHANNELS) {
+                       for (int i = copy->getWidth() * copy->getHeight(); i != 0; i--, src += COM_NUM_CHANNELS_VALUE, dst += COM_NUM_CHANNELS_VALUE) {
                                if (*src > *dst) {
                                        *dst = *src;
                                }
index c78347e7b1cfc9dd99af8dcc9db3354cf90ad847..dde57ab640f1eb8297aa99d08db930c99ff1091b 100644 (file)
@@ -102,15 +102,14 @@ void GaussianAlphaXBlurOperation::executePixel(float output[4], int x, int y, vo
 
        /* *** this is the main part which is different to 'GaussianXBlurOperation'  *** */
        int step = getStep();
-       int offsetadd = getOffsetAdd();
-       int bufferindex = ((xmin - bufferstartx) * 4) + ((ymin - bufferstarty) * 4 * bufferwidth);
+       int bufferindex = ((xmin - bufferstartx)) + ((ymin - bufferstarty) * bufferwidth);
 
        /* gauss */
        float alpha_accum = 0.0f;
        float multiplier_accum = 0.0f;
 
        /* dilate */
-       float value_max = finv_test(buffer[(x * 4) + (y * 4 * bufferwidth)], do_invert); /* init with the current color to avoid unneeded lookups */
+       float value_max = finv_test(buffer[(x) + (y * bufferwidth)], do_invert); /* init with the current color to avoid unneeded lookups */
        float distfacinv_max = 1.0f; /* 0 to 1 */
 
        for (int nx = xmin; nx < xmax; nx += step) {
@@ -134,7 +133,7 @@ void GaussianAlphaXBlurOperation::executePixel(float output[4], int x, int y, vo
                                distfacinv_max = multiplier;
                        }
                }
-               bufferindex += offsetadd;
+               bufferindex += step;
        }
 
        /* blend between the max value and gauss blue - gives nice feather */
index ab97c8b0d13b8f1ad87e7970e0f2f2edccde36f7..bb5b3c044afbeca9b0155513ec151d879464f4df 100644 (file)
@@ -108,11 +108,11 @@ void GaussianAlphaYBlurOperation::executePixel(float output[4], int x, int y, vo
        float multiplier_accum = 0.0f;
 
        /* dilate */
-       float value_max = finv_test(buffer[(x * 4) + (y * 4 * bufferwidth)], do_invert); /* init with the current color to avoid unneeded lookups */
+       float value_max = finv_test(buffer[(x) + (y * bufferwidth)], do_invert); /* init with the current color to avoid unneeded lookups */
        float distfacinv_max = 1.0f; /* 0 to 1 */
 
        for (int ny = ymin; ny < ymax; ny += step) {
-               int bufferindex = ((xmin - bufferstartx) * 4) + ((ny - bufferstarty) * 4 * bufferwidth);
+               int bufferindex = ((xmin - bufferstartx)) + ((ny - bufferstarty) * bufferwidth);
 
                const int index = (ny - y) + this->m_filtersize;
                float value = finv_test(buffer[bufferindex], do_invert);
index 441b623b5899f39907ac4fc7665c1ffd5d9daf68..dbad51c43295a160cd69e5fb7c781f03379cee9d 100644 (file)
@@ -296,7 +296,7 @@ void GaussianBlurReferenceOperation::executePixel(float output[4], int x, int y,
                int minyr = y - refrady < 0 ? -y : -refrady;
                int maxyr = y + refrady > imgy ? imgy - y : refrady;
 
-               float *srcd = buffer + COM_NUMBER_OF_CHANNELS * ( (y + minyr) * imgx + x + minxr);
+               float *srcd = buffer + COM_NUM_CHANNELS_COLOR * ( (y + minyr) * imgx + x + minxr);
 
                gausstabx = m_maintabs[refradx - 1];
                gausstabcentx = gausstabx + refradx;
@@ -304,9 +304,9 @@ void GaussianBlurReferenceOperation::executePixel(float output[4], int x, int y,
                gausstabcenty = gausstaby + refrady;
 
                sum = gval = rval = bval = aval = 0.0f;
-               for (i = minyr; i < maxyr; i++, srcd += COM_NUMBER_OF_CHANNELS * imgx) {
+               for (i = minyr; i < maxyr; i++, srcd += COM_NUM_CHANNELS_COLOR * imgx) {
                        src = srcd;
-                       for (j = minxr; j < maxxr; j++, src += COM_NUMBER_OF_CHANNELS) {
+                       for (j = minxr; j < maxxr; j++, src += COM_NUM_CHANNELS_COLOR) {
                        
                                val = gausstabcenty[i] * gausstabcentx[j];
                                sum += val;
index 99c745d7fb0ff35d4bca5833ab7c387b51fc9b43..98919f1b161ea3b8ec31c05cc02e87ddeaa35749 100644 (file)
@@ -49,7 +49,7 @@ MemoryBuffer *GlareBaseOperation::createMemoryBuffer(rcti *rect2)
        rect.ymin = 0;
        rect.xmax = getWidth();
        rect.ymax = getHeight();
-       MemoryBuffer *result = new MemoryBuffer(NULL, &rect);
+       MemoryBuffer *result = new MemoryBuffer(COM_DT_COLOR, &rect);
        float *data = result->getBuffer();
        this->generateGlare(data, tile, this->m_settings);
        return result;
index 99a7c5b64c42971f1e7317a27e4c795adc4a5776..04993b08ddf6b89b169b4f235b41e328b9ec5090 100644 (file)
@@ -259,8 +259,8 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2)
        float *kernelBuffer = in2->getBuffer();
        float *imageBuffer = in1->getBuffer();
 
-       MemoryBuffer *rdst = new MemoryBuffer(NULL, in1->getRect());
-       memset(rdst->getBuffer(), 0, rdst->getWidth() * rdst->getHeight() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+       MemoryBuffer *rdst = new MemoryBuffer(COM_DT_COLOR, in1->getRect());
+       memset(rdst->getBuffer(), 0, rdst->getWidth() * rdst->getHeight() * COM_NUM_CHANNELS_COLOR * sizeof(float));
 
        // convolution result width & height
        w2 = 2 * kernelWidth - 1;
@@ -276,7 +276,7 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2)
        // normalize convolutor
        wt[0] = wt[1] = wt[2] = 0.f;
        for (y = 0; y < kernelHeight; y++) {
-               colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_NUMBER_OF_CHANNELS];
+               colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_NUM_CHANNELS_COLOR];
                for (x = 0; x < kernelWidth; x++)
                        add_v3_v3(wt, colp[x]);
        }
@@ -284,7 +284,7 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2)
        if (wt[1] != 0.f) wt[1] = 1.f / wt[1];
        if (wt[2] != 0.f) wt[2] = 1.f / wt[2];
        for (y = 0; y < kernelHeight; y++) {
-               colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_NUMBER_OF_CHANNELS];
+               colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_NUM_CHANNELS_COLOR];
                for (x = 0; x < kernelWidth; x++)
                        mul_v3_v3(colp[x], wt);
        }
@@ -313,7 +313,7 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2)
                                        // in2, channel ch -> data1
                                        for (y = 0; y < kernelHeight; y++) {
                                                fp = &data1ch[y * w2];
-                                               colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_NUMBER_OF_CHANNELS];
+                                               colp = (fRGB *)&kernelBuffer[y * kernelWidth * COM_NUM_CHANNELS_COLOR];
                                                for (x = 0; x < kernelWidth; x++)
                                                        fp[x] = colp[x][ch];
                                        }
@@ -325,7 +325,7 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2)
                                        int yy = ybl * ybsz + y;
                                        if (yy >= imageHeight) continue;
                                        fp = &data2[y * w2];
-                                       colp = (fRGB *)&imageBuffer[yy * imageWidth * COM_NUMBER_OF_CHANNELS];
+                                       colp = (fRGB *)&imageBuffer[yy * imageWidth * COM_NUM_CHANNELS_COLOR];
                                        for (x = 0; x < xbsz; x++) {
                                                int xx = xbl * xbsz + x;
                                                if (xx >= imageWidth) continue;
@@ -349,7 +349,7 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2)
                                        const int yy = ybl * ybsz + y - hh;
                                        if ((yy < 0) || (yy >= imageHeight)) continue;
                                        fp = &data2[y * w2];
-                                       colp = (fRGB *)&rdst->getBuffer()[yy * imageWidth * COM_NUMBER_OF_CHANNELS];
+                                       colp = (fRGB *)&rdst->getBuffer()[yy * imageWidth * COM_NUM_CHANNELS_COLOR];
                                        for (x = 0; x < (int)w2; x++) {
                                                const int xx = xbl * xbsz + x - hw;
                                                if ((xx < 0) || (xx >= imageWidth)) continue;
@@ -364,7 +364,7 @@ static void convolve(float *dst, MemoryBuffer *in1, MemoryBuffer *in2)
 
        MEM_freeN(data2);
        MEM_freeN(data1);
-       memcpy(dst, rdst->getBuffer(), sizeof(float) * imageWidth * imageHeight * COM_NUMBER_OF_CHANNELS);
+       memcpy(dst, rdst->getBuffer(), sizeof(float) * imageWidth * imageHeight * COM_NUM_CHANNELS_COLOR);
        delete(rdst);
 }
 
@@ -381,7 +381,7 @@ void GlareFogGlowOperation::generateGlare(float *data, MemoryBuffer *inputTile,
        // make the convolution kernel
        rcti kernelRect;
        BLI_rcti_init(&kernelRect, 0, sz, 0, sz);
-       ckrn = new MemoryBuffer(NULL, &kernelRect);
+       ckrn = new MemoryBuffer(COM_DT_COLOR, &kernelRect);
 
        scale = 0.25f * sqrtf((float)(sz * sz));
 
index 8854be52ded3bd3bd8276e75b681638ecd6249e9..69b5bd7d6bf4909d7f4bfd0601da7cc4c59ce5f1 100644 (file)
@@ -97,7 +97,7 @@ void GlareGhostOperation::generateGlare(float *data, MemoryBuffer *inputTile, No
 
        }
 
-       memset(tbuf1->getBuffer(), 0, tbuf1->getWidth() * tbuf1->getHeight() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+       memset(tbuf1->getBuffer(), 0, tbuf1->getWidth() * tbuf1->getHeight() * COM_NUM_CHANNELS_COLOR * sizeof(float));
        for (n = 1; n < settings->iter && (!breaked); n++) {
                for (y = 0; y < gbuf->getHeight() && (!breaked); y++) {
                        v = ((float)y + 0.5f) / (float)gbuf->getHeight();
@@ -117,9 +117,9 @@ void GlareGhostOperation::generateGlare(float *data, MemoryBuffer *inputTile, No
                        }
                        if (isBreaked()) breaked = true;
                }
-               memcpy(gbuf->getBuffer(), tbuf1->getBuffer(), tbuf1->getWidth() * tbuf1->getHeight() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+               memcpy(gbuf->getBuffer(), tbuf1->getBuffer(), tbuf1->getWidth() * tbuf1->getHeight() * COM_NUM_CHANNELS_COLOR * sizeof(float));
        }
-       memcpy(data, gbuf->getBuffer(), gbuf->getWidth() * gbuf->getHeight() * COM_NUMBER_OF_CHANNELS * sizeof(float));
+       memcpy(data, gbuf->getBuffer(), gbuf->getWidth() * gbuf->getHeight() * COM_NUM_CHANNELS_COLOR * sizeof(float));
 
        delete gbuf;
        delete tbuf1;
index 5644ff30ef3216a6ec1b3673ea850b39231e3dc3..deeb5094bd0cdd9a92ed7cbe64b967d8576f2b6e 100644 (file)
@@ -36,7 +36,7 @@ void GlareStreaksOperation::generateGlare(float *data, MemoryBuffer *inputTile,
        bool breaked = false;
 
        MemoryBuffer *tsrc = inputTile->duplicate();
-       MemoryBuffer *tdst = new MemoryBuffer(NULL, inputTile->getRect());
+       MemoryBuffer *tdst = new MemoryBuffer(COM_DT_COLOR, inputTile->getRect());
        tdst->clear();
        memset(data, 0, size4 * sizeof(float));
 
index b64c98be0c7068c96d80137dec89ebb0497fdfcb..922441a68b65893c96f41bf4f74f362f2447502c 100644 (file)
@@ -83,8 +83,8 @@ float *InpaintSimpleOperation::get_pixel(int x, int y)
        ASSERT_XY_RANGE(x, y);
 
        return &this->m_cached_buffer[
-               y * width * COM_NUMBER_OF_CHANNELS +
-               x * COM_NUMBER_OF_CHANNELS];
+                       y * width * COM_NUM_CHANNELS_COLOR +
+                       x * COM_NUM_CHANNELS_COLOR];
 }
 
 int InpaintSimpleOperation::mdist(int x, int y) 
index ddc09ecb48378d0fbc8edad6f7a5eb06e6182646..72c7512cb23ef75406347c4dcb39d49f0d77a013 100644 (file)
@@ -58,7 +58,7 @@ void KeyingBlurOperation::executePixel(float output[4], int x, int y, void *data
                const int start = max(0, x - this->m_size + 1),
                          end = min(bufferWidth, x + this->m_size);
                for (int cx = start; cx < end; ++cx) {
-                       int bufferIndex = (y * bufferWidth + cx) * 4;
+                       int bufferIndex = (y * bufferWidth + cx);
                        average += buffer[bufferIndex];
                        count++;
                }
@@ -67,7 +67,7 @@ void KeyingBlurOperation::executePixel(float output[4], int x, int y, void *data
                const int start = max(0, y - this->m_size + 1),
                          end = min(inputBuffer->getHeight(), y + this->m_size);
                for (int cy = start; cy < end; ++cy) {
-                       int bufferIndex = (cy * bufferWidth + x) * 4;
+                       int bufferIndex = (cy * bufferWidth + x);
                        average += buffer[bufferIndex];
                        count++;
                }
index d9eb7b588a85d0e60c5d1d5e8ec16b81e3a4e82f..d4ba94f240f648b4966a22678253e668a0c4f6bd 100644 (file)
@@ -62,7 +62,7 @@ void KeyingClipOperation::executePixel(float output[4], int x, int y, void *data
        int bufferWidth = inputBuffer->getWidth();
        int bufferHeight = inputBuffer->getHeight();
 
-       float value = buffer[(y * bufferWidth + x) * 4];
+       float value = buffer[(y * bufferWidth + x)];
 
        bool ok = false;
        int start_x = max_ff(0, x - delta + 1),
@@ -83,7 +83,7 @@ void KeyingClipOperation::executePixel(float output[4], int x, int y, void *data
                                continue;
                        }
 
-                       int bufferIndex = (cy * bufferWidth + cx) * 4;
+                       int bufferIndex = (cy * bufferWidth + cx);
                        float currentValue = buffer[bufferIndex];
 
                        if (fabsf(currentValue - value) < tolerance) {
index 6bf730253e7b27ec3441068ab55861d1b98ec14a..bb8fe825c6898f7e9b317eecb23c8c510b8af2b5 100644 (file)
@@ -83,11 +83,11 @@ bool MapUVOperation::read_uv(float x, float y, float &r_u, float &r_v, float &r_
                return false;
        }
        else {
-               float col[4];
-               m_inputUVProgram->readSampled(col, x, y, COM_PS_BILINEAR);
-               r_u = col[0] * m_inputColorProgram->getWidth();
-               r_v = col[1] * m_inputColorProgram->getHeight();
-               r_alpha = col[2];
+               float vector[3];
+               m_inputUVProgram->readSampled(vector, x, y, COM_PS_BILINEAR);
+               r_u = vector[0] * m_inputColorProgram->getWidth();
+               r_v = vector[1] * m_inputColorProgram->getHeight();
+               r_alpha = vector[2];
                return true;
        }
 }
index f81b50e6836780443d784969f3103fdd0531a036..e0b5893ffbb6619e8d49e604cfd4223ef3c75708 100644 (file)
@@ -104,7 +104,7 @@ void *NormalizeOperation::initializeTileData(rcti *rect)
                        if ((value < minv) && (value >= -BLENDER_ZMAX)) {
                                minv = value;
                        }
-                       bc += 4;
+                       bc ++;
                }
 
                minmult->x = minv;
index d99d6f28eff372775656f4c36bb17df68f60f5eb..4d9c15f974768ff10874db3ad0df9615d6b99921 100644 (file)
@@ -37,15 +37,15 @@ void QualityStepHelper::initExecution(QualityHelper helper)
                                case COM_QUALITY_HIGH:
                                default:
                                        this->m_step = 1;
-                                       this->m_offsetadd = 4;
+                                       this->m_offsetadd = 1;
                                        break;
                                case COM_QUALITY_MEDIUM:
                                        this->m_step = 2;
-                                       this->m_offsetadd = 8;
+                                       this->m_offsetadd = 2;
                                        break;
                                case COM_QUALITY_LOW:
                                        this->m_step = 3;
-                                       this->m_offsetadd = 12;
+                                       this->m_offsetadd = 3;
                                        break;
                        }
                        break;
index 47d5fc6bcca6e2532915673c795abdb533137dbd..709c30f4015fc72115eef6c0fe7bdb8ad066f038 100644 (file)
@@ -24,9 +24,9 @@
 #include "COM_WriteBufferOperation.h"
 #include "COM_defines.h"
 
-ReadBufferOperation::ReadBufferOperation() : NodeOperation()
+ReadBufferOperation::ReadBufferOperation(DataType datatype) : NodeOperation()
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(datatype);
        this->m_single_value = false;
        this->m_offset = 0;
        this->m_buffer = NULL;
@@ -58,11 +58,20 @@ void ReadBufferOperation::executePixelSampled(float output[4], float x, float y,
                /* write buffer has a single value stored at (0,0) */
                m_buffer->read(output, 0, 0);
        }
-       else if (sampler == COM_PS_NEAREST) {
-               m_buffer->read(output, x, y);
-       }
        else {
-               m_buffer->readBilinear(output, x, y);
+               switch (sampler) {
+               case COM_PS_NEAREST:
+                       m_buffer->read(output, x, y);
+                       break;
+               case COM_PS_BILINEAR:
+               default:
+                       m_buffer->readBilinear(output, x, y);
+                       break;
+               case COM_PS_BICUBIC:
+                       m_buffer->readBilinear(output, x, y);
+                       break;
+               }
+
        }
 }
 
index 569920d51ef35969a132595dfa09c2dfd68d1dbf..7e5bc55a8ca8e61137f46bb173f835842339541f 100644 (file)
@@ -25,6 +25,7 @@
 
 #include "COM_NodeOperation.h"
 #include "COM_MemoryProxy.h"
+#include "COM_MemoryBuffer.h"
 
 class ReadBufferOperation : public NodeOperation {
 private:
@@ -33,7 +34,7 @@ private:
        unsigned int m_offset;
        MemoryBuffer *m_buffer;
 public:
-       ReadBufferOperation();
+       ReadBufferOperation(DataType datetype);
        void setMemoryProxy(MemoryProxy *memoryProxy) { this->m_memoryProxy = memoryProxy; }
        MemoryProxy *getMemoryProxy() { return this->m_memoryProxy; }
        void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
index 06f4f6d77cfbd7ecbb86f82781acdc8dd73cc173..f1990453fc6fb60e46863ef59f7738d41921eb6b 100644 (file)
@@ -111,15 +111,6 @@ void RenderLayersBaseProg::doInterpolation(float output[4], float x, float y, Pi
                        BLI_bicubic_interpolation_fl(this->m_inputBuffer, output, width, height, this->m_elementsize, x, y);
                        break;
        }
-
-       if (this->m_elementsize == 1) {
-               output[1] = 0.0f;
-               output[2] = 0.0f;
-               output[3] = 0.0f;
-       }
-       else if (this->m_elementsize == 3) {
-               output[3] = 1.0f;
-       }
 }
 
 void RenderLayersBaseProg::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
@@ -145,7 +136,16 @@ void RenderLayersBaseProg::executePixelSampled(float output[4], float x, float y
 #endif
 
        if (this->m_inputBuffer == NULL) {
-               zero_v4(output);
+               int elemsize = this->m_elementsize;
+               if (elemsize == 1) {
+                       output[0] = 0.0f;
+               }
+               else if (elemsize == 3) {
+                       zero_v3(output);
+               } else {
+                       BLI_assert(elemsize == 4);
+                       zero_v4(output);
+               }
        }
        else {
                doInterpolation(output, x, y, sampler);
@@ -204,15 +204,12 @@ void RenderLayersAlphaProg::executePixelSampled(float output[4], float x, float
        float *inputBuffer = this->getInputBuffer();
 
        if (inputBuffer == NULL) {
-               zero_v4(output);
+               output[0] = 0.0f;
        }
        else {
                float temp[4];
                doInterpolation(temp, x, y, sampler);
                output[0] = temp[3];
-               output[1] = 0.0f;
-               output[2] = 0.0f;
-               output[3] = 0.0f;
        }
 }
 
@@ -227,7 +224,7 @@ RenderLayersColorOperation::RenderLayersColorOperation() : RenderLayersBaseProg(
 
 RenderLayersCyclesOperation::RenderLayersCyclesOperation(int pass) : RenderLayersBaseProg(pass, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Depth Operation ******** */
@@ -245,16 +242,10 @@ void RenderLayersDepthProg::executePixelSampled(float output[4], float x, float
 
        if (inputBuffer == NULL || ix < 0 || iy < 0 || ix >= (int)this->getWidth() || iy >= (int)this->getHeight() ) {
                output[0] = 0.0f;
-               output[1] = 0.0f;
-               output[2] = 0.0f;
-               output[3] = 0.0f;
        }
        else {
                unsigned int offset = (iy * this->getWidth() + ix);
                output[0] = inputBuffer[offset];
-               output[1] = 0.0f;
-               output[2] = 0.0f;
-               output[3] = 0.0f;
        }
 }
 
@@ -262,21 +253,21 @@ void RenderLayersDepthProg::executePixelSampled(float output[4], float x, float
 
 RenderLayersDiffuseOperation::RenderLayersDiffuseOperation() : RenderLayersBaseProg(SCE_PASS_DIFFUSE, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Emit Operation ******** */
 
 RenderLayersEmitOperation::RenderLayersEmitOperation() : RenderLayersBaseProg(SCE_PASS_EMIT, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Environment Operation ******** */
 
 RenderLayersEnvironmentOperation::RenderLayersEnvironmentOperation() : RenderLayersBaseProg(SCE_PASS_ENVIRONMENT, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Image Operation ******** */
@@ -290,7 +281,7 @@ RenderLayersColorProg::RenderLayersColorProg() : RenderLayersBaseProg(SCE_PASS_C
 
 RenderLayersIndirectOperation::RenderLayersIndirectOperation() : RenderLayersBaseProg(SCE_PASS_INDIRECT, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Material Index Operation ******** */
@@ -325,28 +316,28 @@ RenderLayersObjectIndexOperation::RenderLayersObjectIndexOperation() : RenderLay
 
 RenderLayersReflectionOperation::RenderLayersReflectionOperation() : RenderLayersBaseProg(SCE_PASS_REFLECT, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Refraction Operation ******** */
 
 RenderLayersRefractionOperation::RenderLayersRefractionOperation() : RenderLayersBaseProg(SCE_PASS_REFRACT, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Shadow Operation ******** */
 
 RenderLayersShadowOperation::RenderLayersShadowOperation() : RenderLayersBaseProg(SCE_PASS_SHADOW, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Specular Operation ******** */
 
 RenderLayersSpecularOperation::RenderLayersSpecularOperation() : RenderLayersBaseProg(SCE_PASS_SPEC, 3)
 {
-       this->addOutputSocket(COM_DT_COLOR);
+       this->addOutputSocket(COM_DT_VECTOR);
 }
 
 /* ******** Render Layers Speed Operation ******** */
index 17212d78e15a8a0f566ca6c3b69851d1ad63484d..769eaf1d2ed45d72a3f06fd5648dcdeead0027c7 100644 (file)
@@ -33,7 +33,6 @@ void SetVectorOperation::executePixelSampled(float output[4], float x, float y,
        output[0] = this->m_x;
        output[1] = this->m_y;
        output[2] = this->m_z;
-       output[3] = this->m_w;
 }
 
 void SetVectorOperation::determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2])
index 12b04c386f2eaeea77c47939e34d39a0f6e2a837..0ca687ea1620fb491f16105cdbe2126c126f2f11 100644 (file)
@@ -135,7 +135,7 @@ struct BufferLineAccumulator {
 
                falloff_factor = dist_max > dist_min ? dr / (float)(dist_max - dist_min) : 0.0f;
 
-               float *iter = input->getBuffer() + COM_NUMBER_OF_CHANNELS * (x + input->getWidth() * y);
+               float *iter = input->getBuffer() + COM_NUM_CHANNELS_COLOR * (x + input->getWidth() * y);
                return iter;
        }
 
@@ -159,7 +159,7 @@ struct BufferLineAccumulator {
                zero_v4(output);
                
                if ((int)(co[0] - source[0]) == 0 && (int)(co[1] - source[1]) == 0) {
-                       copy_v4_v4(output, input->getBuffer() + COM_NUMBER_OF_CHANNELS * ((int)source[0] + input->getWidth() * (int)source[1]));
+                       copy_v4_v4(output, input->getBuffer() + COM_NUM_CHANNELS_COLOR * ((int)source[0] + input->getWidth() * (int)source[1]));
                        return;
                }
 
@@ -198,7 +198,7 @@ struct BufferLineAccumulator {
                        /* decrement u */
                        x -= fxu;
                        y -= fyu;
-                       buffer -= (fxu + fyu * buffer_width) * COM_NUMBER_OF_CHANNELS;
+                       buffer -= (fxu + fyu * buffer_width) * COM_NUM_CHANNELS_COLOR;
 
                        /* decrement v (in steps of dv < 1) */
                        v_local -= dv;
@@ -207,7 +207,7 @@ struct BufferLineAccumulator {
 
                                x -= fxv;
                                y -= fyv;
-                               buffer -= (fxv + fyv * buffer_width) * COM_NUMBER_OF_CHANNELS;
+                               buffer -= (fxv + fyv * buffer_width) * COM_NUM_CHANNELS_COLOR;
                        }
                }
 
index ede767cbff73a91408cc400d255ae0a1da9a2c60..da01aa3b7ca0a1b172859c1cec068e46881aea90 100644 (file)
@@ -77,12 +77,9 @@ void TextureBaseOperation::determineResolution(unsigned int resolution[2], unsig
 
 void TextureAlphaOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
-       TextureBaseOperation::executePixelSampled(output, x, y, sampler);
-       output[0] = output[3];
-       output[1] = 0.0f;
-       output[2] = 0.0f;
-       output[3] = 0.0f;
-}
+       float color[4];
+       TextureBaseOperation::executePixelSampled(color, x, y, sampler);
+       output[0] = color[3];}
 
 void TextureBaseOperation::executePixelSampled(float output[4], float x, float y, PixelSampler sampler)
 {
@@ -124,18 +121,23 @@ MemoryBuffer *TextureBaseOperation::createMemoryBuffer(rcti *rect2)
 {
        int height = getHeight();
        int width = getWidth();
+       DataType datatype = this->getOutputSocket()->getDataType();
+       int add = 4;
+       if (datatype == COM_DT_VALUE) {
+               add = 1;
+       }
 
        rcti rect;
        rect.xmin = 0;
        rect.ymin = 0;
        rect.xmax = width;
        rect.ymax = height;
-       MemoryBuffer *result = new MemoryBuffer(NULL, &rect);
+       MemoryBuffer *result = new MemoryBuffer(datatype, &rect);
 
        float *data = result->getBuffer();
 
        for (int y = 0; y < height; y++) {
-               for (int x = 0; x < width; x++, data += 4) {
+               for (int x = 0; x < width; x++, data += add) {
                        this->executePixelSampled(data, x, y, COM_PS_NEAREST);
                }
        }
index 4b81001fdab1140192b5b490e3a0b9823b3ee22d..4809efd74364b6afe0e3c1bb1d8ecf92b4402226 100644 (file)
@@ -137,30 +137,33 @@ void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y,
                copy_v4_fl(multiplier_accum, 1.0f);
                float size_center = tempSize[0] * scalar;
                
-               const int addXStep = QualityStepHelper::getStep() * COM_NUMBER_OF_CHANNELS;
-               
+               const int addXStepValue = QualityStepHelper::getStep();
+               const int addYStepValue = addXStepValue;
+               const int addXStepColor = addXStepValue * COM_NUM_CHANNELS_COLOR;
+
                if (size_center > this->m_threshold) {
-                       for (int ny = miny; ny < maxy; ny += QualityStepHelper::getStep()) {
+                       for (int ny = miny; ny < maxy; ny += addYStepValue) {
                                float dy = ny - y;
-                               int offsetNy = ny * inputSizeBuffer->getWidth() * COM_NUMBER_OF_CHANNELS;
-                               int offsetNxNy = offsetNy + (minx * COM_NUMBER_OF_CHANNELS);
-                               for (int nx = minx; nx < maxx; nx += QualityStepHelper::getStep()) {
+                               int offsetValueNy = ny * inputSizeBuffer->getWidth();
+                               int offsetValueNxNy = offsetValueNy + (minx);
+                               int offsetColorNxNy = offsetValueNxNy * COM_NUM_CHANNELS_COLOR;
+                               for (int nx = minx; nx < maxx; nx += addXStepValue) {
                                        if (nx != x || ny != y) {
-                                               float size = min(inputSizeFloatBuffer[offsetNxNy] * scalar, size_center);
+                                               float size = min(inputSizeFloatBuffer[offsetValueNxNy] * scalar, size_center);
                                                if (size > this->m_threshold) {
                                                        float dx = nx - x;
                                                        if (size > fabsf(dx) && size > fabsf(dy)) {
                                                                float uv[2] = {
-                                                                   (float)(COM_BLUR_BOKEH_PIXELS / 2) + (dx / size) * (float)((COM_BLUR_BOKEH_PIXELS / 2) - 1),
-                                                                   (float)(COM_BLUR_BOKEH_PIXELS / 2) + (dy / size) * (float)((COM_BLUR_BOKEH_PIXELS / 2) - 1)};
-                                                               inputBokehBuffer->readNoCheck(bokeh, uv[0], uv[1]);
-                                                               madd_v4_v4v4(color_accum, bokeh, &inputProgramFloatBuffer[offsetNxNy]);
+                                                                       (float)(COM_BLUR_BOKEH_PIXELS / 2) + (dx / size) * (float)((COM_BLUR_BOKEH_PIXELS / 2) - 1),
+                                                                       (float)(COM_BLUR_BOKEH_PIXELS / 2) + (dy / size) * (float)((COM_BLUR_BOKEH_PIXELS / 2) - 1)};
+                                                               inputBokehBuffer->read(bokeh, uv[0], uv[1]);
+                                                               madd_v4_v4v4(color_accum, bokeh, &inputProgramFloatBuffer[offsetColorNxNy]);
                                                                add_v4_v4(multiplier_accum, bokeh);
                                                        }
                                                }
                                        }
-                                       offsetNxNy += addXStep;
-                               }
+                                       offsetColorNxNy += addXStepColor;
+                                       offsetValueNxNy += addXStepValue;                               }
                        }
                }
 
index f5890157440178a2a3a32b0b91c215c418a6523a..8dc06ef07d7c9230071d907f745fbcc4fd8880a0 100644 (file)
@@ -57,7 +57,7 @@ void VectorBlurOperation::initExecution()
 void VectorBlurOperation::executePixel(float output[4], int x, int y, void *data)
 {
        float *buffer = (float *) data;
-       int index = (y * this->getWidth() + x) * COM_NUMBER_OF_CHANNELS;
+       int index = (y * this->getWidth() + x) * COM_NUM_CHANNELS_COLOR;
        copy_v4_v4(output, &buffer[index]);
 }
 
@@ -108,14 +108,12 @@ bool VectorBlurOperation::determineDependingAreaOfInterest(rcti *input, ReadBuff
 
 void VectorBlurOperation::generateVectorBlur(float *data, MemoryBuffer *inputImage, MemoryBuffer *inputSpeed, MemoryBuffer *inputZ)
 {
-       float *zbuf = inputZ->convertToValueBuffer();
        NodeBlurData blurdata;
        blurdata.samples = this->m_settings->samples / QualityStepHelper::getStep();
        blurdata.maxspeed = this->m_settings->maxspeed;
        blurdata.minspeed = this->m_settings->minspeed;
        blurdata.curved = this->m_settings->curved;
        blurdata.fac = this->m_settings->fac;
-       RE_zbuf_accumulate_vecblur(&blurdata, this->getWidth(), this->getHeight(), data, inputImage->getBuffer(), inputSpeed->getBuffer(), zbuf);
-       MEM_freeN((void *)zbuf);
+       RE_zbuf_accumulate_vecblur(&blurdata, this->getWidth(), this->getHeight(), data, inputImage->getBuffer(), inputSpeed->getBuffer(), inputZ->getBuffer());
        return;
 }
index fedc8c6db7dab22bbee2e3d24f3da55118d2fe26..dfdc54012a880522328b8de7547fa571892e358b 100644 (file)
@@ -51,7 +51,6 @@ void VectorCurveOperation::executePixelSampled(float output[4], float x, float y
        this->m_inputProgram->readSampled(input, x, y, sampler);
 
        curvemapping_evaluate_premulRGBF(this->m_curveMapping, output, input);
-       output[3] = input[3];
 }
 
 void VectorCurveOperation::deinitExecution()
index c30361d1df8175beaeef624537cf97891d08925c..7fbef453a139994e141e3533971d5c4e5b0d8cf6 100644 (file)
@@ -23,7 +23,7 @@
 
 #include "COM_WrapOperation.h"
 
-WrapOperation::WrapOperation() : ReadBufferOperation()
+WrapOperation::WrapOperation(DataType datatype) : ReadBufferOperation(datatype)
 {
        this->m_wrappingType = CMP_NODE_WRAP_NONE;
 }
index 33ea128056461b6ff23be7313198a8b9784e1211..92c93565691c23ac64e93a0924f273a8570d503a 100644 (file)
@@ -29,7 +29,7 @@ class WrapOperation : public ReadBufferOperation {
 private:
        int m_wrappingType;
 public:
-       WrapOperation();
+       WrapOperation(DataType datetype);
        bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
        void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);
 
index 832864b399d4b8100897c768356de100eef128d7..fccff2a33bf3f4cfbae621b7a7e0f6ba8c3a9b35 100644 (file)
 #include <stdio.h>
 #include "COM_OpenCLDevice.h"
 
-WriteBufferOperation::WriteBufferOperation() : NodeOperation()
+WriteBufferOperation::WriteBufferOperation(DataType datatype) : NodeOperation()
 {
-       this->addInputSocket(COM_DT_COLOR);
-       this->m_memoryProxy = new MemoryProxy();
+       this->addInputSocket(datatype);
+       this->m_memoryProxy = new MemoryProxy(datatype);
        this->m_memoryProxy->setWriteBufferOperation(this);
        this->m_memoryProxy->setExecutor(NULL);
 }
@@ -61,6 +61,7 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber)
 {
        MemoryBuffer *memoryBuffer = this->m_memoryProxy->getBuffer();
        float *buffer = memoryBuffer->getBuffer();
+       const int num_channels = memoryBuffer->get_num_channels();
        if (this->m_input->isComplex()) {
                void *data = this->m_input->initializeTileData(rect);
                int x1 = rect->xmin;
@@ -71,10 +72,10 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber)
                int y;
                bool breaked = false;
                for (y = y1; y < y2 && (!breaked); y++) {
-                       int offset4 = (y * memoryBuffer->getWidth() + x1) * COM_NUMBER_OF_CHANNELS;
+                       int offset4 = (y * memoryBuffer->getWidth() + x1) * num_channels;
                        for (x = x1; x < x2; x++) {
                                this->m_input->read(&(buffer[offset4]), x, y, data);
-                               offset4 += COM_NUMBER_OF_CHANNELS;
+                               offset4 += num_channels;
                        }
                        if (isBreaked()) {
                                breaked = true;
@@ -96,10 +97,10 @@ void WriteBufferOperation::executeRegion(rcti *rect, unsigned int tileNumber)
                int y;
                bool breaked = false;
                for (y = y1; y < y2 && (!breaked); y++) {
-                       int offset4 = (y * memoryBuffer->getWidth() + x1) * COM_NUMBER_OF_CHANNELS;
+                       int offset4 = (y * memoryBuffer->getWidth() + x1) * num_channels;
                        for (x = x1; x < x2; x++) {
                                this->m_input->readSampled(&(buffer[offset4]), x, y, COM_PS_NEAREST);
-                               offset4 += COM_NUMBER_OF_CHANNELS;
+                               offset4 += num_channels;
                        }
                        if (isBreaked()) {
                                breaked = true;
@@ -126,12 +127,9 @@ void WriteBufferOperation::executeOpenCLRegion(OpenCLDevice *device, rcti *rect,
        const unsigned int outputBufferWidth = outputBuffer->getWidth();
        const unsigned int outputBufferHeight = outputBuffer->getHeight();
 
-       const cl_image_format imageFormat = {
-               CL_RGBA,
-               CL_FLOAT
-       };
+       const cl_image_format *imageFormat = device->determineImageFormat(outputBuffer);
 
-       cl_mem clOutputBuffer = clCreateImage2D(device->getContext(), CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR, &imageFormat, outputBufferWidth, outputBufferHeight, 0, outputFloatBuffer, &error);
+       cl_mem clOutputBuffer = clCreateImage2D(device->getContext(), CL_MEM_WRITE_ONLY | CL_MEM_USE_HOST_PTR, imageFormat, outputBufferWidth, outputBufferHeight, 0, outputFloatBuffer, &error);
        if (error != CL_SUCCESS) { printf("CLERROR[%d]: %s\n", error, clewErrorString(error));  }
        
        // STEP 2
index 96466df979c7118ffc597ed1119ad591bb39c9ed..9220cb179c6ae3094b062d12ce926ba70c5a5dbb 100644 (file)
@@ -35,7 +35,7 @@ class WriteBufferOperation : public NodeOperation {
        bool m_single_value; /* single value stored in buffer */
        NodeOperation *m_input;
 public:
-       WriteBufferOperation();
+       WriteBufferOperation(DataType datatype);
        ~WriteBufferOperation();
        MemoryProxy *getMemoryProxy() { return this->m_memoryProxy; }
        void executePixelSampled(float output[4], float x, float y, PixelSampler sampler);