code cleanup: remove unused and unsupported functions from libmv-capi
[blender.git] / source / blender / compositor / intern / COM_NodeOperation.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Contributor: 
19  *              Jeroen Bakker 
20  *              Monique Dewanchand
21  */
22
23 #ifndef _COM_NodeOperation_h
24 #define _COM_NodeOperation_h
25 class OpenCLDevice;
26 #include "COM_Node.h"
27 #include <string>
28 #include <sstream>
29 #include "COM_MemoryBuffer.h"
30 #include "COM_MemoryProxy.h"
31 #include "COM_SocketReader.h"
32 #include "OCL_opencl.h"
33 #include "list"
34 #include "BLI_threads.h"
35
36 #include "BLI_math_color.h"
37 #include "BLI_math_vector.h"
38
39 class ReadBufferOperation;
40
41 /**
42  * @brief NodeOperation are contains calculation logic
43  *
44  * Subclasses needs to implement the execution method (defined in SocketReader) to implement logic.
45  * @ingroup Model
46  */
47 class NodeOperation : public NodeBase, public SocketReader {
48 private:
49         /**
50          * @brief the index of the input socket that will be used to determine the resolution
51          */
52         unsigned int m_resolutionInputSocketIndex;
53
54         /**
55          * @brief is this operation a complex one.
56          *
57          * Complex operations are typically doing many reads to calculate the output of a single pixel.
58          * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
59          */
60         bool m_complex;
61
62         /**
63          * @brief can this operation be scheduled on an OpenCL device.
64          * @note Only applicable if complex is True
65          */
66         bool m_openCL;
67
68         /**
69          * @brief mutex reference for very special node initializations
70          * @note only use when you really know what you are doing.
71          * this mutex is used to share data among chunks in the same operation
72          * @see TonemapOperation for an example of usage
73          * @see NodeOperation.initMutex initializes this mutex
74          * @see NodeOperation.deinitMutex deinitializes this mutex
75          * @see NodeOperation.getMutex retrieve a pointer to this mutex.
76          */
77         ThreadMutex m_mutex;
78         
79         /**
80          * @brief reference to the editing bNodeTree, used for break and update callback
81          */
82         const bNodeTree *m_btree;
83
84         bool m_isResolutionSet;
85 public:
86         /**
87          * @brief is this node an operation?
88          * This is true when the instance is of the subclass NodeOperation.
89          * @return [true:false]
90          * @see NodeBase
91          */
92         const bool isOperation() const { return true; }
93
94         /**
95          * @brief determine the resolution of this node
96          * @note this method will not set the resolution, this is the responsibility of the caller
97          * @param resolution the result of this operation
98          * @param preferredResolution the preferable resolution as no resolution could be determined
99          */
100         virtual void determineResolution(unsigned int resolution[2], unsigned int preferredResolution[2]);
101
102         /**
103          * @brief isOutputOperation determines whether this operation is an output of the ExecutionSystem during rendering or editing.
104          *
105          * Default behaviour if not overridden, this operation will not be evaluated as being an output of the ExecutionSystem.
106          *
107          * @see ExecutionSystem
108          * @group check
109          * @param rendering [true false]
110          *  true: rendering
111          *  false: editing
112          *
113          * @return bool the result of this method
114          */
115         virtual bool isOutputOperation(bool rendering) const { return false; }
116
117         /**
118          * isBufferOperation returns if this is an operation that work directly on buffers.
119          *
120          * there are only 2 implementation where this is true:
121          * @see ReadBufferOperation
122          * @see WriteBufferOperation
123          * for all other operations this will result in false.
124          */
125         virtual int isBufferOperation() { return false; }
126         virtual int isSingleThreaded() { return false; }
127
128         void setbNodeTree(const bNodeTree *tree) { this->m_btree = tree; }
129         virtual void initExecution();
130         
131         /**
132          * @brief when a chunk is executed by a CPUDevice, this method is called
133          * @ingroup execution
134          * @param rect the rectangle of the chunk (location and size)
135          * @param chunkNumber the chunkNumber to be calculated
136          * @param memoryBuffers all input MemoryBuffer's needed
137          */
138         virtual void executeRegion(rcti *rect, unsigned int chunkNumber) {}
139
140         /**
141          * @brief when a chunk is executed by an OpenCLDevice, this method is called
142          * @ingroup execution
143          * @note this method is only implemented in WriteBufferOperation
144          * @param context the OpenCL context
145          * @param program the OpenCL program containing all compositor kernels
146          * @param queue the OpenCL command queue of the device the chunk is executed on
147          * @param rect the rectangle of the chunk (location and size)
148          * @param chunkNumber the chunkNumber to be calculated
149          * @param memoryBuffers all input MemoryBuffer's needed
150          * @param outputBuffer the outputbuffer to write to
151          */
152         virtual void executeOpenCLRegion(OpenCLDevice *device, rcti *rect,
153                                          unsigned int chunkNumber, MemoryBuffer **memoryBuffers, MemoryBuffer *outputBuffer) {}
154
155         /**
156          * @brief custom handle to add new tasks to the OpenCL command queue in order to execute a chunk on an GPUDevice
157          * @ingroup execution
158          * @param context the OpenCL context
159          * @param program the OpenCL program containing all compositor kernels
160          * @param queue the OpenCL command queue of the device the chunk is executed on
161          * @param outputMemoryBuffer the allocated memory buffer in main CPU memory
162          * @param clOutputBuffer the allocated memory buffer in OpenCLDevice memory
163          * @param inputMemoryBuffers all input MemoryBuffer's needed
164          * @param clMemToCleanUp all created cl_mem references must be added to this list. Framework will clean this after execution
165          * @param clKernelsToCleanUp all created cl_kernel references must be added to this list. Framework will clean this after execution
166          */
167         virtual void executeOpenCL(OpenCLDevice *device,
168                                    MemoryBuffer *outputMemoryBuffer, cl_mem clOutputBuffer,
169                                    MemoryBuffer **inputMemoryBuffers, list<cl_mem> *clMemToCleanUp,
170                                    list<cl_kernel> *clKernelsToCleanUp) {}
171         virtual void deinitExecution();
172
173         bool isResolutionSet() {
174                 return this->m_isResolutionSet;
175         }
176
177         /**
178          * @brief set the resolution
179          * @param resolution the resolution to set
180          */
181         void setResolution(unsigned int resolution[2]) {
182                 if (!isResolutionSet()) {
183                         this->m_width = resolution[0];
184                         this->m_height = resolution[1];
185                         this->m_isResolutionSet = true;
186                 }
187         }
188         
189
190         void getConnectedInputSockets(vector<InputSocket *> *sockets);
191
192         /**
193          * @brief is this operation complex
194          *
195          * Complex operations are typically doing many reads to calculate the output of a single pixel.
196          * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
197          */
198         const bool isComplex() const { return this->m_complex; }
199         virtual const bool isSetOperation() const { return false; }
200
201         /**
202          * @brief is this operation of type ReadBufferOperation
203          * @return [true:false]
204          * @see ReadBufferOperation
205          */
206         virtual const bool isReadBufferOperation() const { return false; }
207
208         /**
209          * @brief is this operation of type WriteBufferOperation
210          * @return [true:false]
211          * @see WriteBufferOperation
212          */
213         virtual const bool isWriteBufferOperation() const { return false; }
214
215         /**
216          * @brief is this operation the active viewer output
217          * user can select an ViewerNode to be active (the result of this node will be drawn on the backdrop)
218          * @return [true:false]
219          * @see BaseViewerOperation
220          */
221         virtual const bool isActiveViewerOutput() const { return false; }
222
223         virtual bool determineDependingAreaOfInterest(rcti *input, ReadBufferOperation *readOperation, rcti *output);
224
225         /**
226          * @brief set the index of the input socket that will determine the resolution of this operation
227          * @param index the index to set
228          */
229         void setResolutionInputSocketIndex(unsigned int index);
230
231         /**
232          * @brief get the render priority of this node.
233          * @note only applicable for output operations like ViewerOperation
234          * @return CompositorPriority
235          */
236         virtual const CompositorPriority getRenderPriority() const { return COM_PRIORITY_LOW; }
237
238         /**
239          * @brief can this NodeOperation be scheduled on an OpenCLDevice
240          * @see WorkScheduler.schedule
241          * @see ExecutionGroup.addOperation
242          */
243         bool isOpenCL() { return this->m_openCL; }
244         
245         virtual bool isViewerOperation() { return false; }
246         virtual bool isPreviewOperation() { return false; }
247         
248         inline bool isBreaked() {
249                 return this->m_btree->test_break(this->m_btree->tbh);
250         }
251
252         inline void updateDraw() {
253                 if (this->m_btree->update_draw)
254                         this->m_btree->update_draw(this->m_btree->udh);
255         }
256 protected:
257         NodeOperation();
258
259         void setWidth(unsigned int width) { this->m_width = width; this->m_isResolutionSet = true; }
260         void setHeight(unsigned int height) { this->m_height = height; this->m_isResolutionSet = true; }
261         SocketReader *getInputSocketReader(unsigned int inputSocketindex);
262         NodeOperation *getInputOperation(unsigned int inputSocketindex);
263
264         void deinitMutex();
265         void initMutex();
266         void lockMutex();
267         void unlockMutex();
268         
269
270         /**
271          * @brief set whether this operation is complex
272          *
273          * Complex operations are typically doing many reads to calculate the output of a single pixel.
274          * Mostly Filter types (Blurs, Convolution, Defocus etc) need this to be set to true.
275          */
276         void setComplex(bool complex) { this->m_complex = complex; }
277
278         /**
279          * @brief set if this NodeOperation can be scheduled on a OpenCLDevice
280          */
281         void setOpenCL(bool openCL) { this->m_openCL = openCL; }
282
283 #ifdef WITH_CXX_GUARDEDALLOC
284         MEM_CXX_CLASS_ALLOC_FUNCS("COM:NodeOperation")
285 #endif
286 };
287
288 #endif