diff options
Diffstat (limited to 'source/blender/compositor/intern/COM_ExecutionGroup.cpp')
-rw-r--r-- | source/blender/compositor/intern/COM_ExecutionGroup.cpp | 230 |
1 files changed, 115 insertions, 115 deletions
diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.cpp b/source/blender/compositor/intern/COM_ExecutionGroup.cpp index 4dfb9c7d26c..5aa9ff21070 100644 --- a/source/blender/compositor/intern/COM_ExecutionGroup.cpp +++ b/source/blender/compositor/intern/COM_ExecutionGroup.cpp @@ -43,20 +43,20 @@ ExecutionGroup::ExecutionGroup() { - this->isOutput = false; - this->complex = false; - this->chunkExecutionStates = NULL; - this->bTree = NULL; - this->height = 0; - this->width = 0; - this->cachedMaxReadBufferOffset = 0; - this->numberOfXChunks = 0; - this->numberOfYChunks = 0; - this->numberOfChunks = 0; - this->initialized = false; - this->openCL = false; - this->singleThreaded = false; - this->chunksFinished = 0; + this->m_isOutput = false; + this->m_complex = false; + this->m_chunkExecutionStates = NULL; + this->m_bTree = NULL; + this->m_height = 0; + this->m_width = 0; + this->m_cachedMaxReadBufferOffset = 0; + this->m_numberOfXChunks = 0; + this->m_numberOfYChunks = 0; + this->m_numberOfChunks = 0; + this->m_initialized = false; + this->m_openCL = false; + this->m_singleThreaded = false; + this->m_chunksFinished = 0; } CompositorPriority ExecutionGroup::getRenderPriotrity() @@ -66,7 +66,7 @@ CompositorPriority ExecutionGroup::getRenderPriotrity() bool ExecutionGroup::containsOperation(NodeOperation *operation) { - for (vector<NodeOperation *>::const_iterator iterator = this->operations.begin(); iterator != this->operations.end(); ++iterator) { + for (vector<NodeOperation *>::const_iterator iterator = this->m_operations.begin(); iterator != this->m_operations.end(); ++iterator) { NodeOperation *inListOperation = *iterator; if (inListOperation == operation) { return true; @@ -77,12 +77,12 @@ bool ExecutionGroup::containsOperation(NodeOperation *operation) const bool ExecutionGroup::isComplex() const { - return this->complex; + return this->m_complex; } bool ExecutionGroup::canContainOperation(NodeOperation *operation) { - if (!this->initialized) { return true; } + if (!this->m_initialized) { return true; } if (operation->isReadBufferOperation()) { return true; } if (operation->isWriteBufferOperation()) { return false; } if (operation->isSetOperation()) { return true; } @@ -100,12 +100,12 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat if (containsOperation(operation)) return; if (canContainOperation(operation)) { if (!operation->isBufferOperation()) { - this->complex = operation->isComplex(); - this->openCL = operation->isOpenCL(); - this->singleThreaded = operation->isSingleThreaded(); - this->initialized = true; + this->m_complex = operation->isComplex(); + this->m_openCL = operation->isOpenCL(); + this->m_singleThreaded = operation->isSingleThreaded(); + this->m_initialized = true; } - this->operations.push_back(operation); + this->m_operations.push_back(operation); if (operation->isReadBufferOperation()) { ReadBufferOperation *readOperation = (ReadBufferOperation *)operation; WriteBufferOperation *writeOperation = readOperation->getMemoryProxy()->getWriteBufferOperation(); @@ -137,52 +137,52 @@ void ExecutionGroup::addOperation(ExecutionSystem *system, NodeOperation *operat NodeOperation *ExecutionGroup::getOutputNodeOperation() const { - return this->operations[0]; // the first operation of the group is always the output operation. + return this->m_operations[0]; // the first operation of the group is always the output operation. } void ExecutionGroup::initExecution() { - if (this->chunkExecutionStates != NULL) { - delete[] this->chunkExecutionStates; + if (this->m_chunkExecutionStates != NULL) { + delete[] this->m_chunkExecutionStates; } unsigned int index; determineNumberOfChunks(); - this->chunkExecutionStates = NULL; - if (this->numberOfChunks != 0) { - this->chunkExecutionStates = new ChunkExecutionState[numberOfChunks]; - for (index = 0; index < numberOfChunks; index++) { - this->chunkExecutionStates[index] = COM_ES_NOT_SCHEDULED; + this->m_chunkExecutionStates = NULL; + if (this->m_numberOfChunks != 0) { + this->m_chunkExecutionStates = new ChunkExecutionState[this->m_numberOfChunks]; + for (index = 0; index < this->m_numberOfChunks; index++) { + this->m_chunkExecutionStates[index] = COM_ES_NOT_SCHEDULED; } } unsigned int maxNumber = 0; - for (index = 0; index < this->operations.size(); index++) { - NodeOperation *operation = this->operations[index]; + for (index = 0; index < this->m_operations.size(); index++) { + NodeOperation *operation = this->m_operations[index]; if (operation->isReadBufferOperation()) { ReadBufferOperation *readOperation = (ReadBufferOperation *)operation; - this->cachedReadOperations.push_back(readOperation); + this->m_cachedReadOperations.push_back(readOperation); maxNumber = max(maxNumber, readOperation->getOffset()); } } maxNumber++; - this->cachedMaxReadBufferOffset = maxNumber; + this->m_cachedMaxReadBufferOffset = maxNumber; } void ExecutionGroup::deinitExecution() { - if (this->chunkExecutionStates != NULL) { - delete[] this->chunkExecutionStates; - this->chunkExecutionStates = NULL; - } - this->numberOfChunks = 0; - this->numberOfXChunks = 0; - this->numberOfYChunks = 0; - this->cachedReadOperations.clear(); - this->bTree = NULL; + if (this->m_chunkExecutionStates != NULL) { + delete[] this->m_chunkExecutionStates; + this->m_chunkExecutionStates = NULL; + } + this->m_numberOfChunks = 0; + this->m_numberOfXChunks = 0; + this->m_numberOfYChunks = 0; + this->m_cachedReadOperations.clear(); + this->m_bTree = NULL; } void ExecutionGroup::determineResolution(unsigned int resolution[]) { @@ -194,16 +194,16 @@ void ExecutionGroup::determineResolution(unsigned int resolution[]) void ExecutionGroup::determineNumberOfChunks() { - if (singleThreaded) { - this->numberOfXChunks = 1; - this->numberOfYChunks = 1; - this->numberOfChunks = 1; + if (this->m_singleThreaded) { + this->m_numberOfXChunks = 1; + this->m_numberOfYChunks = 1; + this->m_numberOfChunks = 1; } else { - const float chunkSizef = this->chunkSize; - this->numberOfXChunks = ceil(this->width / chunkSizef); - this->numberOfYChunks = ceil(this->height / chunkSizef); - this->numberOfChunks = this->numberOfXChunks * this->numberOfYChunks; + const float chunkSizef = this->m_chunkSize; + this->m_numberOfXChunks = ceil(this->m_width / chunkSizef); + this->m_numberOfYChunks = ceil(this->m_height / chunkSizef); + this->m_numberOfChunks = this->m_numberOfXChunks * this->m_numberOfYChunks; } } @@ -214,17 +214,17 @@ void ExecutionGroup::execute(ExecutionSystem *graph) { CompositorContext& context = graph->getContext(); const bNodeTree *bTree = context.getbNodeTree(); - if (this->width == 0 || this->height == 0) {return; } /// @note: break out... no pixels to calculate. + if (this->m_width == 0 || this->m_height == 0) {return; } /// @note: break out... no pixels to calculate. if (bTree->test_break && bTree->test_break(bTree->tbh)) {return; } /// @note: early break out for blur and preview nodes - if (this->numberOfChunks == 0) {return; } /// @note: early break out + if (this->m_numberOfChunks == 0) {return; } /// @note: early break out unsigned int chunkNumber; - this->chunksFinished = 0; - this->bTree = bTree; + this->m_chunksFinished = 0; + this->m_bTree = bTree; unsigned int index; - unsigned int *chunkOrder = new unsigned int[this->numberOfChunks]; + unsigned int *chunkOrder = new unsigned int[this->m_numberOfChunks]; - for (chunkNumber = 0; chunkNumber < this->numberOfChunks; chunkNumber++) { + for (chunkNumber = 0; chunkNumber < this->m_numberOfChunks; chunkNumber++) { chunkOrder[chunkNumber] = chunkNumber; } NodeOperation *operation = this->getOutputNodeOperation(); @@ -241,9 +241,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph) switch (chunkorder) { case COM_TO_RANDOM: - for (index = 0; index < 2 * numberOfChunks; index++) { - int index1 = rand() % numberOfChunks; - int index2 = rand() % numberOfChunks; + for (index = 0; index < 2 * this->m_numberOfChunks; index++) { + int index1 = rand() % this->m_numberOfChunks; + int index2 = rand() % this->m_numberOfChunks; int s = chunkOrder[index1]; chunkOrder[index1] = chunkOrder[index2]; chunkOrder[index2] = s; @@ -252,10 +252,10 @@ void ExecutionGroup::execute(ExecutionSystem *graph) case COM_TO_CENTER_OUT: { ChunkOrderHotspot **hotspots = new ChunkOrderHotspot *[1]; - hotspots[0] = new ChunkOrderHotspot(this->width * centerX, this->height * centerY, 0.0f); + hotspots[0] = new ChunkOrderHotspot(this->m_width * centerX, this->m_height * centerY, 0.0f); rcti rect; - ChunkOrder *chunkOrders = new ChunkOrder[this->numberOfChunks]; - for (index = 0; index < this->numberOfChunks; index++) { + ChunkOrder *chunkOrders = new ChunkOrder[this->m_numberOfChunks]; + for (index = 0; index < this->m_numberOfChunks; index++) { determineChunkRect(&rect, index); chunkOrders[index].setChunkNumber(index); chunkOrders[index].setX(rect.xmin); @@ -263,8 +263,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph) chunkOrders[index].determineDistance(hotspots, 1); } - sort(&chunkOrders[0], &chunkOrders[numberOfChunks - 1]); - for (index = 0; index < numberOfChunks; index++) { + sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks - 1]); + for (index = 0; index < this->m_numberOfChunks; index++) { chunkOrder[index] = chunkOrders[index].getChunkNumber(); } @@ -276,14 +276,14 @@ void ExecutionGroup::execute(ExecutionSystem *graph) case COM_TO_RULE_OF_THIRDS: { ChunkOrderHotspot **hotspots = new ChunkOrderHotspot *[9]; - unsigned int tx = this->width / 6; - unsigned int ty = this->height / 6; - unsigned int mx = this->width / 2; - unsigned int my = this->height / 2; + unsigned int tx = this->m_width / 6; + unsigned int ty = this->m_height / 6; + unsigned int mx = this->m_width / 2; + unsigned int my = this->m_height / 2; unsigned int bx = mx + 2 * tx; unsigned int by = my + 2 * ty; - float addition = numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER; + float addition = this->m_numberOfChunks / COM_RULE_OF_THIRDS_DIVIDER; hotspots[0] = new ChunkOrderHotspot(mx, my, addition * 0); hotspots[1] = new ChunkOrderHotspot(tx, my, addition * 1); hotspots[2] = new ChunkOrderHotspot(bx, my, addition * 2); @@ -294,8 +294,8 @@ void ExecutionGroup::execute(ExecutionSystem *graph) hotspots[7] = new ChunkOrderHotspot(mx, ty, addition * 7); hotspots[8] = new ChunkOrderHotspot(mx, by, addition * 8); rcti rect; - ChunkOrder *chunkOrders = new ChunkOrder[this->numberOfChunks]; - for (index = 0; index < this->numberOfChunks; index++) { + ChunkOrder *chunkOrders = new ChunkOrder[this->m_numberOfChunks]; + for (index = 0; index < this->m_numberOfChunks; index++) { determineChunkRect(&rect, index); chunkOrders[index].setChunkNumber(index); chunkOrders[index].setX(rect.xmin); @@ -303,9 +303,9 @@ void ExecutionGroup::execute(ExecutionSystem *graph) chunkOrders[index].determineDistance(hotspots, 9); } - sort(&chunkOrders[0], &chunkOrders[numberOfChunks]); + sort(&chunkOrders[0], &chunkOrders[this->m_numberOfChunks]); - for (index = 0; index < numberOfChunks; index++) { + for (index = 0; index < this->m_numberOfChunks; index++) { chunkOrder[index] = chunkOrders[index].getChunkNumber(); } @@ -338,11 +338,11 @@ void ExecutionGroup::execute(ExecutionSystem *graph) finished = true; int numberEvaluated = 0; - for (index = startIndex; index < numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) { + for (index = startIndex; index < this->m_numberOfChunks && numberEvaluated < maxNumberEvaluated; index++) { int chunkNumber = chunkOrder[index]; - int yChunk = chunkNumber / this->numberOfXChunks; - int xChunk = chunkNumber - (yChunk * this->numberOfXChunks); - const ChunkExecutionState state = this->chunkExecutionStates[chunkNumber]; + int yChunk = chunkNumber / this->m_numberOfXChunks; + int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks); + const ChunkExecutionState state = this->m_chunkExecutionStates[chunkNumber]; if (state == COM_ES_NOT_SCHEDULED) { scheduleChunkWhenPossible(graph, xChunk, yChunk); finished = false; @@ -375,12 +375,12 @@ MemoryBuffer **ExecutionGroup::getInputBuffersCPU() unsigned int index; this->determineDependingMemoryProxies(&memoryproxies); - MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->cachedMaxReadBufferOffset]; - for (index = 0; index < this->cachedMaxReadBufferOffset; index++) { + MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->m_cachedMaxReadBufferOffset]; + for (index = 0; index < this->m_cachedMaxReadBufferOffset; index++) { memoryBuffers[index] = NULL; } - for (index = 0; index < this->cachedReadOperations.size(); index++) { - ReadBufferOperation *readOperation = (ReadBufferOperation *)this->cachedReadOperations[index]; + for (index = 0; index < this->m_cachedReadOperations.size(); index++) { + ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index]; memoryBuffers[readOperation->getOffset()] = readOperation->getMemoryProxy()->getBuffer(); } return memoryBuffers; @@ -394,13 +394,13 @@ MemoryBuffer **ExecutionGroup::getInputBuffersOpenCL(int chunkNumber) determineChunkRect(&rect, chunkNumber); this->determineDependingMemoryProxies(&memoryproxies); - MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->cachedMaxReadBufferOffset]; - for (index = 0; index < this->cachedMaxReadBufferOffset; index++) { + MemoryBuffer **memoryBuffers = new MemoryBuffer *[this->m_cachedMaxReadBufferOffset]; + for (index = 0; index < this->m_cachedMaxReadBufferOffset; index++) { memoryBuffers[index] = NULL; } rcti output; - for (index = 0; index < this->cachedReadOperations.size(); index++) { - ReadBufferOperation *readOperation = (ReadBufferOperation *)this->cachedReadOperations[index]; + for (index = 0; index < this->m_cachedReadOperations.size(); index++) { + ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index]; MemoryProxy *memoryProxy = readOperation->getMemoryProxy(); this->determineDependingAreaOfInterest(&rect, readOperation, &output); MemoryBuffer *memoryBuffer = memoryProxy->getExecutor()->constructConsolidatedMemoryBuffer(memoryProxy, &output); @@ -419,12 +419,12 @@ MemoryBuffer *ExecutionGroup::constructConsolidatedMemoryBuffer(MemoryProxy *mem void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers) { - if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) - this->chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED; + if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) + this->m_chunkExecutionStates[chunkNumber] = COM_ES_EXECUTED; - this->chunksFinished++; + this->m_chunksFinished++; if (memoryBuffers) { - for (unsigned int index = 0; index < this->cachedMaxReadBufferOffset; index++) { + for (unsigned int index = 0; index < this->m_cachedMaxReadBufferOffset; index++) { MemoryBuffer *buffer = memoryBuffers[index]; if (buffer) { if (buffer->isTemporarily()) { @@ -435,30 +435,30 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo } delete[] memoryBuffers; } - if (bTree) { + if (this->m_bTree) { // status report is only performed for top level Execution Groups. - float progress = chunksFinished; - progress /= numberOfChunks; - bTree->progress(bTree->prh, progress); + float progress = this->m_chunksFinished; + progress /= this->m_numberOfChunks; + this->m_bTree->progress(this->m_bTree->prh, progress); } } inline void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk) const { - if (singleThreaded) { - BLI_init_rcti(rect, 0, this->width, 0, this->height); + if (this->m_singleThreaded) { + BLI_init_rcti(rect, 0, this->m_width, 0, this->m_height); } else { - const unsigned int minx = xChunk * chunkSize; - const unsigned int miny = yChunk * chunkSize; - BLI_init_rcti(rect, minx, min(minx + this->chunkSize, this->width), miny, min(miny + this->chunkSize, this->height)); + const unsigned int minx = xChunk * this->m_chunkSize; + const unsigned int miny = yChunk * this->m_chunkSize; + BLI_init_rcti(rect, minx, min(minx + this->m_chunkSize, this->m_width), miny, min(miny + this->m_chunkSize, this->m_height)); } } void ExecutionGroup::determineChunkRect(rcti *rect, const unsigned int chunkNumber) const { - const unsigned int yChunk = chunkNumber / numberOfXChunks; - const unsigned int xChunk = chunkNumber - (yChunk * numberOfXChunks); + const unsigned int yChunk = chunkNumber / this->m_numberOfXChunks; + const unsigned int xChunk = chunkNumber - (yChunk * this->m_numberOfXChunks); determineChunkRect(rect, xChunk, yChunk); } @@ -477,13 +477,13 @@ MemoryBuffer *ExecutionGroup::allocateOutputBuffer(int chunkNumber, rcti *rect) bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area) { - if (singleThreaded) { + if (this->m_singleThreaded) { return scheduleChunkWhenPossible(graph, 0, 0); } // find all chunks inside the rect // determine minxchunk, minychunk, maxxchunk, maxychunk where x and y are chunknumbers - float chunkSizef = this->chunkSize; + float chunkSizef = this->m_chunkSize; int indexx, indexy; const int minxchunk = floor(area->xmin / chunkSizef); @@ -505,8 +505,8 @@ bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber) { - if (this->chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) { - this->chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED; + if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_NOT_SCHEDULED) { + this->m_chunkExecutionStates[chunkNumber] = COM_ES_SCHEDULED; WorkScheduler::schedule(this, chunkNumber); return true; } @@ -515,20 +515,20 @@ bool ExecutionGroup::scheduleChunk(unsigned int chunkNumber) bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChunk, int yChunk) { - if (xChunk < 0 || xChunk >= (int)this->numberOfXChunks) { + if (xChunk < 0 || xChunk >= (int)this->m_numberOfXChunks) { return true; } - if (yChunk < 0 || yChunk >= (int)this->numberOfYChunks) { + if (yChunk < 0 || yChunk >= (int)this->m_numberOfYChunks) { return true; } - int chunkNumber = yChunk * this->numberOfXChunks + xChunk; + int chunkNumber = yChunk * this->m_numberOfXChunks + xChunk; // chunk is already executed - if (this->chunkExecutionStates[chunkNumber] == COM_ES_EXECUTED) { + if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_EXECUTED) { return true; } // chunk is scheduled, but not executed - if (this->chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) { + if (this->m_chunkExecutionStates[chunkNumber] == COM_ES_SCHEDULED) { return false; } @@ -542,8 +542,8 @@ bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph, int xChun bool canBeExecuted = true; rcti area; - for (index = 0; index < cachedReadOperations.size(); index++) { - ReadBufferOperation *readOperation = (ReadBufferOperation *)cachedReadOperations[index]; + for (index = 0; index < this->m_cachedReadOperations.size(); index++) { + ReadBufferOperation *readOperation = (ReadBufferOperation *)this->m_cachedReadOperations[index]; BLI_init_rcti(&area, 0, 0, 0, 0); MemoryProxy *memoryProxy = memoryProxies[index]; determineDependingAreaOfInterest(&rect, readOperation, &area); @@ -574,13 +574,13 @@ void ExecutionGroup::determineDependingAreaOfInterest(rcti *input, ReadBufferOpe void ExecutionGroup::determineDependingMemoryProxies(vector<MemoryProxy *> *memoryProxies) { unsigned int index; - for (index = 0; index < this->cachedReadOperations.size(); index++) { - ReadBufferOperation *readOperation = (ReadBufferOperation *) this->cachedReadOperations[index]; + for (index = 0; index < this->m_cachedReadOperations.size(); index++) { + ReadBufferOperation *readOperation = (ReadBufferOperation *) this->m_cachedReadOperations[index]; memoryProxies->push_back(readOperation->getMemoryProxy()); } } bool ExecutionGroup::isOpenCL() { - return this->openCL; + return this->m_openCL; } |