1 files changed, 84 insertions, 95 deletions

diff --git a/source/blender/compositor/intern/COM_ExecutionGroup.cc b/source/blender/compositor/intern/COM_ExecutionGroup.cc
index 655bc030dec..8841f44ea48 100644
--- a/source/blender/compositor/intern/COM_ExecutionGroup.cc
+++ b/source/blender/compositor/intern/COM_ExecutionGroup.cc
@@ -56,16 +56,16 @@ std::ostream &operator<<(std::ostream &os, const ExecutionGroupFlags &flags)
 ExecutionGroup::ExecutionGroup(int id)
 {
   m_id = id;
-  this->m_bTree = nullptr;
-  this->m_height = 0;
-  this->m_width = 0;
-  this->m_max_read_buffer_offset = 0;
-  this->m_x_chunks_len = 0;
-  this->m_y_chunks_len = 0;
-  this->m_chunks_len = 0;
-  this->m_chunks_finished = 0;
-  BLI_rcti_init(&this->m_viewerBorder, 0, 0, 0, 0);
-  this->m_executionStartTime = 0;
+  m_bTree = nullptr;
+  m_height = 0;
+  m_width = 0;
+  m_max_read_buffer_offset = 0;
+  m_x_chunks_len = 0;
+  m_y_chunks_len = 0;
+  m_chunks_len = 0;
+  m_chunks_finished = 0;
+  BLI_rcti_init(&m_viewerBorder, 0, 0, 0, 0);
+  m_executionStartTime = 0;
 }
 
 std::ostream &operator<<(std::ostream &os, const ExecutionGroup &execution_group)
@@ -139,8 +139,8 @@ NodeOperation *ExecutionGroup::getOutputOperation() const
 void ExecutionGroup::init_work_packages()
 {
   m_work_packages.clear();
-  if (this->m_chunks_len != 0) {
-    m_work_packages.resize(this->m_chunks_len);
+  if (m_chunks_len != 0) {
+    m_work_packages.resize(m_chunks_len);
     for (unsigned int index = 0; index < m_chunks_len; index++) {
       m_work_packages[index].type = eWorkPackageType::Tile;
       m_work_packages[index].state = eWorkPackageState::NotScheduled;
@@ -157,12 +157,12 @@ void ExecutionGroup::init_read_buffer_operations()
   for (NodeOperation *operation : m_operations) {
     if (operation->get_flags().is_read_buffer_operation) {
       ReadBufferOperation *readOperation = static_cast<ReadBufferOperation *>(operation);
-      this->m_read_operations.append(readOperation);
+      m_read_operations.append(readOperation);
       max_offset = MAX2(max_offset, readOperation->getOffset());
     }
   }
   max_offset++;
-  this->m_max_read_buffer_offset = max_offset;
+  m_max_read_buffer_offset = max_offset;
 }
 
 void ExecutionGroup::initExecution()
@@ -175,11 +175,11 @@ void ExecutionGroup::initExecution()
 void ExecutionGroup::deinitExecution()
 {
   m_work_packages.clear();
-  this->m_chunks_len = 0;
-  this->m_x_chunks_len = 0;
-  this->m_y_chunks_len = 0;
-  this->m_read_operations.clear();
-  this->m_bTree = nullptr;
+  m_chunks_len = 0;
+  m_x_chunks_len = 0;
+  m_y_chunks_len = 0;
+  m_read_operations.clear();
+  m_bTree = nullptr;
 }
 
 void ExecutionGroup::determineResolution(unsigned int resolution[2])
@@ -188,30 +188,30 @@ void ExecutionGroup::determineResolution(unsigned int resolution[2])
   resolution[0] = operation->getWidth();
   resolution[1] = operation->getHeight();
   this->setResolution(resolution);
-  BLI_rcti_init(&this->m_viewerBorder, 0, this->m_width, 0, this->m_height);
+  BLI_rcti_init(&m_viewerBorder, 0, m_width, 0, m_height);
 }
 
 void ExecutionGroup::init_number_of_chunks()
 {
-  if (this->m_flags.single_threaded) {
-    this->m_x_chunks_len = 1;
-    this->m_y_chunks_len = 1;
-    this->m_chunks_len = 1;
+  if (m_flags.single_threaded) {
+    m_x_chunks_len = 1;
+    m_y_chunks_len = 1;
+    m_chunks_len = 1;
   }
   else {
-    const float chunkSizef = this->m_chunkSize;
-    const int border_width = BLI_rcti_size_x(&this->m_viewerBorder);
-    const int border_height = BLI_rcti_size_y(&this->m_viewerBorder);
-    this->m_x_chunks_len = ceil(border_width / chunkSizef);
-    this->m_y_chunks_len = ceil(border_height / chunkSizef);
-    this->m_chunks_len = this->m_x_chunks_len * this->m_y_chunks_len;
+    const float chunkSizef = m_chunkSize;
+    const int border_width = BLI_rcti_size_x(&m_viewerBorder);
+    const int border_height = BLI_rcti_size_y(&m_viewerBorder);
+    m_x_chunks_len = ceil(border_width / chunkSizef);
+    m_y_chunks_len = ceil(border_height / chunkSizef);
+    m_chunks_len = m_x_chunks_len * m_y_chunks_len;
   }
 }
 
 blender::Array<unsigned int> ExecutionGroup::get_execution_order() const
 {
   blender::Array<unsigned int> chunk_order(m_chunks_len);
-  for (int chunk_index = 0; chunk_index < this->m_chunks_len; chunk_index++) {
+  for (int chunk_index = 0; chunk_index < m_chunks_len; chunk_index++) {
     chunk_order[chunk_index] = chunk_index;
   }
 
@@ -227,8 +227,8 @@ blender::Array<unsigned int> ExecutionGroup::get_execution_order() const
     order_type = viewer->getChunkOrder();
   }
 
-  const int border_width = BLI_rcti_size_x(&this->m_viewerBorder);
-  const int border_height = BLI_rcti_size_y(&this->m_viewerBorder);
+  const int border_width = BLI_rcti_size_x(&m_viewerBorder);
+  const int border_height = BLI_rcti_size_y(&m_viewerBorder);
   int index;
   switch (order_type) {
     case ChunkOrdering::Random: {
@@ -242,16 +242,16 @@ blender::Array<unsigned int> ExecutionGroup::get_execution_order() const
     case ChunkOrdering::CenterOut: {
       ChunkOrderHotspot hotspot(border_width * centerX, border_height * centerY, 0.0f);
       blender::Array<ChunkOrder> chunk_orders(m_chunks_len);
-      for (index = 0; index < this->m_chunks_len; index++) {
+      for (index = 0; index < m_chunks_len; index++) {
         const WorkPackage &work_package = m_work_packages[index];
         chunk_orders[index].index = index;
-        chunk_orders[index].x = work_package.rect.xmin - this->m_viewerBorder.xmin;
-        chunk_orders[index].y = work_package.rect.ymin - this->m_viewerBorder.ymin;
+        chunk_orders[index].x = work_package.rect.xmin - m_viewerBorder.xmin;
+        chunk_orders[index].y = work_package.rect.ymin - m_viewerBorder.ymin;
         chunk_orders[index].update_distance(&hotspot, 1);
       }
 
-      std::sort(&chunk_orders[0], &chunk_orders[this->m_chunks_len - 1]);
-      for (index = 0; index < this->m_chunks_len; index++) {
+      std::sort(&chunk_orders[0], &chunk_orders[m_chunks_len - 1]);
+      for (index = 0; index < m_chunks_len; index++) {
         chunk_order[index] = chunk_orders[index].index;
       }
 
@@ -264,7 +264,7 @@ blender::Array<unsigned int> ExecutionGroup::get_execution_order() const
       unsigned int my = border_height / 2;
       unsigned int bx = mx + 2 * tx;
       unsigned int by = my + 2 * ty;
-      float addition = this->m_chunks_len / COM_RULE_OF_THIRDS_DIVIDER;
+      float addition = m_chunks_len / COM_RULE_OF_THIRDS_DIVIDER;
 
       ChunkOrderHotspot hotspots[9]{
           ChunkOrderHotspot(mx, my, addition * 0),
@@ -279,17 +279,17 @@ blender::Array<unsigned int> ExecutionGroup::get_execution_order() const
       };
 
       blender::Array<ChunkOrder> chunk_orders(m_chunks_len);
-      for (index = 0; index < this->m_chunks_len; index++) {
+      for (index = 0; index < m_chunks_len; index++) {
         const WorkPackage &work_package = m_work_packages[index];
         chunk_orders[index].index = index;
-        chunk_orders[index].x = work_package.rect.xmin - this->m_viewerBorder.xmin;
-        chunk_orders[index].y = work_package.rect.ymin - this->m_viewerBorder.ymin;
+        chunk_orders[index].x = work_package.rect.xmin - m_viewerBorder.xmin;
+        chunk_orders[index].y = work_package.rect.ymin - m_viewerBorder.ymin;
         chunk_orders[index].update_distance(hotspots, 9);
       }
 
-      std::sort(&chunk_orders[0], &chunk_orders[this->m_chunks_len]);
+      std::sort(&chunk_orders[0], &chunk_orders[m_chunks_len]);
 
-      for (index = 0; index < this->m_chunks_len; index++) {
+      for (index = 0; index < m_chunks_len; index++) {
         chunk_order[index] = chunk_orders[index].index;
       }
 
@@ -310,21 +310,21 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
 {
   const CompositorContext &context = graph->getContext();
   const bNodeTree *bTree = context.getbNodeTree();
-  if (this->m_width == 0 || this->m_height == 0) {
+  if (m_width == 0 || 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->m_chunks_len == 0) {
+  if (m_chunks_len == 0) {
     return;
   } /** \note Early break out. */
   unsigned int chunk_index;
 
-  this->m_executionStartTime = PIL_check_seconds_timer();
+  m_executionStartTime = PIL_check_seconds_timer();
 
-  this->m_chunks_finished = 0;
-  this->m_bTree = bTree;
+  m_chunks_finished = 0;
+  m_bTree = bTree;
 
   blender::Array<unsigned int> chunk_order = get_execution_order();
 
@@ -341,12 +341,11 @@ void ExecutionGroup::execute(ExecutionSystem *graph)
     finished = true;
     int numberEvaluated = 0;
 
-    for (int index = startIndex;
-         index < this->m_chunks_len && numberEvaluated < maxNumberEvaluated;
+    for (int index = startIndex; index < m_chunks_len && numberEvaluated < maxNumberEvaluated;
          index++) {
       chunk_index = chunk_order[index];
-      int yChunk = chunk_index / this->m_x_chunks_len;
-      int xChunk = chunk_index - (yChunk * this->m_x_chunks_len);
+      int yChunk = chunk_index / m_x_chunks_len;
+      int xChunk = chunk_index - (yChunk * m_x_chunks_len);
       const WorkPackage &work_package = m_work_packages[chunk_index];
       switch (work_package.state) {
         case eWorkPackageState::NotScheduled: {
@@ -389,7 +388,7 @@ MemoryBuffer **ExecutionGroup::getInputBuffersOpenCL(int chunkNumber)
   WorkPackage &work_package = m_work_packages[chunkNumber];
 
   MemoryBuffer **memoryBuffers = (MemoryBuffer **)MEM_callocN(
-      sizeof(MemoryBuffer *) * this->m_max_read_buffer_offset, __func__);
+      sizeof(MemoryBuffer *) * m_max_read_buffer_offset, __func__);
   rcti output;
   for (ReadBufferOperation *readOperation : m_read_operations) {
     MemoryProxy *memoryProxy = readOperation->getMemoryProxy();
@@ -417,9 +416,9 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
     work_package.state = eWorkPackageState::Executed;
   }
 
-  atomic_add_and_fetch_u(&this->m_chunks_finished, 1);
+  atomic_add_and_fetch_u(&m_chunks_finished, 1);
   if (memoryBuffers) {
-    for (unsigned int index = 0; index < this->m_max_read_buffer_offset; index++) {
+    for (unsigned int index = 0; index < m_max_read_buffer_offset; index++) {
       MemoryBuffer *buffer = memoryBuffers[index];
       if (buffer) {
         if (buffer->isTemporarily()) {
@@ -430,19 +429,16 @@ void ExecutionGroup::finalizeChunkExecution(int chunkNumber, MemoryBuffer **memo
     }
     MEM_freeN(memoryBuffers);
   }
-  if (this->m_bTree) {
+  if (m_bTree) {
     /* Status report is only performed for top level Execution Groups. */
-    float progress = this->m_chunks_finished;
-    progress /= this->m_chunks_len;
-    this->m_bTree->progress(this->m_bTree->prh, progress);
+    float progress = m_chunks_finished;
+    progress /= m_chunks_len;
+    m_bTree->progress(m_bTree->prh, progress);
 
     char buf[128];
-    BLI_snprintf(buf,
-                 sizeof(buf),
-                 TIP_("Compositing | Tile %u-%u"),
-                 this->m_chunks_finished,
-                 this->m_chunks_len);
-    this->m_bTree->stats_draw(this->m_bTree->sdh, buf);
+    BLI_snprintf(
+        buf, sizeof(buf), TIP_("Compositing | Tile %u-%u"), m_chunks_finished, m_chunks_len);
+    m_bTree->stats_draw(m_bTree->sdh, buf);
   }
 }
 
@@ -450,30 +446,29 @@ inline void ExecutionGroup::determineChunkRect(rcti *r_rect,
                                                const unsigned int xChunk,
                                                const unsigned int yChunk) const
 {
-  const int border_width = BLI_rcti_size_x(&this->m_viewerBorder);
-  const int border_height = BLI_rcti_size_y(&this->m_viewerBorder);
+  const int border_width = BLI_rcti_size_x(&m_viewerBorder);
+  const int border_height = BLI_rcti_size_y(&m_viewerBorder);
 
-  if (this->m_flags.single_threaded) {
-    BLI_rcti_init(
-        r_rect, this->m_viewerBorder.xmin, border_width, this->m_viewerBorder.ymin, border_height);
+  if (m_flags.single_threaded) {
+    BLI_rcti_init(r_rect, m_viewerBorder.xmin, border_width, m_viewerBorder.ymin, border_height);
   }
   else {
-    const unsigned int minx = xChunk * this->m_chunkSize + this->m_viewerBorder.xmin;
-    const unsigned int miny = yChunk * this->m_chunkSize + this->m_viewerBorder.ymin;
-    const unsigned int width = MIN2((unsigned int)this->m_viewerBorder.xmax, this->m_width);
-    const unsigned int height = MIN2((unsigned int)this->m_viewerBorder.ymax, this->m_height);
+    const unsigned int minx = xChunk * m_chunkSize + m_viewerBorder.xmin;
+    const unsigned int miny = yChunk * m_chunkSize + m_viewerBorder.ymin;
+    const unsigned int width = MIN2((unsigned int)m_viewerBorder.xmax, m_width);
+    const unsigned int height = MIN2((unsigned int)m_viewerBorder.ymax, m_height);
     BLI_rcti_init(r_rect,
-                  MIN2(minx, this->m_width),
-                  MIN2(minx + this->m_chunkSize, width),
-                  MIN2(miny, this->m_height),
-                  MIN2(miny + this->m_chunkSize, height));
+                  MIN2(minx, m_width),
+                  MIN2(minx + m_chunkSize, width),
+                  MIN2(miny, m_height),
+                  MIN2(miny + m_chunkSize, height));
   }
 }
 
 void ExecutionGroup::determineChunkRect(rcti *r_rect, const unsigned int chunkNumber) const
 {
-  const unsigned int yChunk = chunkNumber / this->m_x_chunks_len;
-  const unsigned int xChunk = chunkNumber - (yChunk * this->m_x_chunks_len);
+  const unsigned int yChunk = chunkNumber / m_x_chunks_len;
+  const unsigned int xChunk = chunkNumber - (yChunk * m_x_chunks_len);
   determineChunkRect(r_rect, xChunk, yChunk);
 }
 
@@ -492,7 +487,7 @@ MemoryBuffer *ExecutionGroup::allocateOutputBuffer(rcti &rect)
 
 bool ExecutionGroup::scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area)
 {
-  if (this->m_flags.single_threaded) {
+  if (m_flags.single_threaded) {
     return scheduleChunkWhenPossible(graph, 0, 0);
   }
   /* Find all chunks inside the rect
@@ -540,15 +535,15 @@ bool ExecutionGroup::scheduleChunkWhenPossible(ExecutionSystem *graph,
                                                const int chunk_x,
                                                const int chunk_y)
 {
-  if (chunk_x < 0 || chunk_x >= (int)this->m_x_chunks_len) {
+  if (chunk_x < 0 || chunk_x >= (int)m_x_chunks_len) {
     return true;
   }
-  if (chunk_y < 0 || chunk_y >= (int)this->m_y_chunks_len) {
+  if (chunk_y < 0 || chunk_y >= (int)m_y_chunks_len) {
     return true;
   }
 
   /* Check if chunk is already executed or scheduled and not yet executed. */
-  const int chunk_index = chunk_y * this->m_x_chunks_len + chunk_x;
+  const int chunk_index = chunk_y * m_x_chunks_len + chunk_x;
   WorkPackage &work_package = m_work_packages[chunk_index];
   if (work_package.state == eWorkPackageState::Executed) {
     return true;
@@ -589,11 +584,8 @@ void ExecutionGroup::setViewerBorder(float xmin, float xmax, float ymin, float y
 {
   const NodeOperation &operation = *this->getOutputOperation();
   if (operation.get_flags().use_viewer_border) {
-    BLI_rcti_init(&this->m_viewerBorder,
-                  xmin * this->m_width,
-                  xmax * this->m_width,
-                  ymin * this->m_height,
-                  ymax * this->m_height);
+    BLI_rcti_init(
+        &m_viewerBorder, xmin * m_width, xmax * m_width, ymin * m_height, ymax * m_height);
   }
 }
 
@@ -601,11 +593,8 @@ void ExecutionGroup::setRenderBorder(float xmin, float xmax, float ymin, float y
 {
   const NodeOperation &operation = *this->getOutputOperation();
   if (operation.isOutputOperation(true) && operation.get_flags().use_render_border) {
-    BLI_rcti_init(&this->m_viewerBorder,
-                  xmin * this->m_width,
-                  xmax * this->m_width,
-                  ymin * this->m_height,
-                  ymax * this->m_height);
+    BLI_rcti_init(
+        &m_viewerBorder, xmin * m_width, xmax * m_width, ymin * m_height, ymax * m_height);
   }
 }