Task scheduler: Use single parallel range function with more flexible function

Now all the fine-tuning is happening using parallel range settings structure,
which avoid passing long lists of arguments, allows extend fine-tuning further,
avoid having lots of various functions which basically does the same thing.

12 files changed, 439 insertions, 123 deletions

diff --git a/source/blender/blenkernel/intern/CCGSubSurf_legacy.c b/source/blender/blenkernel/intern/CCGSubSurf_legacy.c
index 8b3ea249396..363b7cff453 100644
--- a/source/blender/blenkernel/intern/CCGSubSurf_legacy.c
+++ b/source/blender/blenkernel/intern/CCGSubSurf_legacy.c
@@ -331,10 +331,15 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss,
 	    .numEffectedF = numEffectedF
 	};
 
-	BLI_task_parallel_range(0, numEffectedF,
-	                        &data,
-	                        ccgSubSurf__calcVertNormals_faces_accumulate_cb,
-	                        numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+	{
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+		BLI_task_parallel_range(0, numEffectedF,
+		                        &data,
+		                        ccgSubSurf__calcVertNormals_faces_accumulate_cb,
+		                        &settings);
+	}
 
 	/* XXX can I reduce the number of normalisations here? */
 	for (ptrIdx = 0; ptrIdx < numEffectedV; ptrIdx++) {
@@ -360,15 +365,25 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss,
 		}
 	}
 
-	BLI_task_parallel_range(0, numEffectedE,
-	                        &data,
-	                        ccgSubSurf__calcVertNormals_edges_accumulate_cb,
-	                        numEffectedE * edgeSize * 4 >= CCG_OMP_LIMIT);
+	{
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (numEffectedE * edgeSize * 4 >= CCG_OMP_LIMIT);
+		BLI_task_parallel_range(0, numEffectedE,
+		                        &data,
+		                        ccgSubSurf__calcVertNormals_edges_accumulate_cb,
+		                        &settings);
+	}
 
-	BLI_task_parallel_range(0, numEffectedF,
-	                        &data,
-	                        ccgSubSurf__calcVertNormals_faces_finalize_cb,
-	                        numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+	{
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+		BLI_task_parallel_range(0, numEffectedF,
+		                        &data,
+		                        ccgSubSurf__calcVertNormals_faces_finalize_cb,
+		                        &settings);
+	}
 
 	for (ptrIdx = 0; ptrIdx < numEffectedE; ptrIdx++) {
 		CCGEdge *e = (CCGEdge *) effectedE[ptrIdx];
@@ -653,10 +668,15 @@ static void ccgSubSurf__calcSubdivLevel(
 	    .curLvl = curLvl
 	};
 
-	BLI_task_parallel_range(0, numEffectedF,
-	                        &data,
-	                        ccgSubSurf__calcSubdivLevel_interior_faces_edges_midpoints_cb,
-	                        numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+	{
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+		BLI_task_parallel_range(0, numEffectedF,
+		                        &data,
+		                        ccgSubSurf__calcSubdivLevel_interior_faces_edges_midpoints_cb,
+		                        &settings);
+	}
 
 	/* exterior edge midpoints
 	 * - old exterior edge points
@@ -931,10 +951,15 @@ static void ccgSubSurf__calcSubdivLevel(
 		}
 	}
 
-	BLI_task_parallel_range(0, numEffectedF,
-	                        &data,
-	                        ccgSubSurf__calcSubdivLevel_interior_faces_edges_centerpoints_shift_cb,
-	                        numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+	{
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+		BLI_task_parallel_range(0, numEffectedF,
+		                        &data,
+		                        ccgSubSurf__calcSubdivLevel_interior_faces_edges_centerpoints_shift_cb,
+		                        &settings);
+	}
 
 	/* copy down */
 	edgeSize = ccg_edgesize(nextLvl);
@@ -946,10 +971,15 @@ static void ccgSubSurf__calcSubdivLevel(
 		VertDataCopy(EDGE_getCo(e, nextLvl, edgeSize - 1), VERT_getCo(e->v1, nextLvl), ss);
 	}
 
-	BLI_task_parallel_range(0, numEffectedF,
-	                        &data,
-	                        ccgSubSurf__calcSubdivLevel_verts_copydata_cb,
-	                        numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+	{
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
+		BLI_task_parallel_range(0, numEffectedF,
+		                        &data,
+		                        ccgSubSurf__calcSubdivLevel_verts_copydata_cb,
+		                        &settings);
+	}
 }
 
 void ccgSubSurf__sync_legacy(CCGSubSurf *ss)
diff --git a/source/blender/blenkernel/intern/colortools.c b/source/blender/blenkernel/intern/colortools.c
index 67153564a0f..46d06a3ac78 100644
--- a/source/blender/blenkernel/intern/colortools.c
+++ b/source/blender/blenkernel/intern/colortools.c
@@ -1387,8 +1387,16 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, const ColorManagedViewSettings *
 	ScopesUpdateDataChunk data_chunk = {{0}};
 	INIT_MINMAX(data_chunk.min, data_chunk.max);
 
-	BLI_task_parallel_range_finalize(0, ibuf->y, &data, &data_chunk, sizeof(data_chunk),
-	                                 scopes_update_cb, scopes_update_finalize, ibuf->y > 256, false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (ibuf->y > 256);
+	settings.userdata_chunk = &data_chunk;
+	settings.userdata_chunk_size = sizeof(data_chunk);
+	settings.func_finalize = scopes_update_finalize;
+	BLI_task_parallel_range(0, ibuf->y,
+	                        &data,
+	                        scopes_update_cb,
+	                        &settings);
 
 	/* test for nicer distribution even - non standard, leave it out for a while */
 #if 0
diff --git a/source/blender/blenkernel/intern/dynamicpaint.c b/source/blender/blenkernel/intern/dynamicpaint.c
index 81a721e77b9..4b7193adc21 100644
--- a/source/blender/blenkernel/intern/dynamicpaint.c
+++ b/source/blender/blenkernel/intern/dynamicpaint.c
@@ -709,10 +709,19 @@ static void surfaceGenerateGrid(struct DynamicPaintSurface *surface)
 		/* calculate canvas dimensions */
 		/* Important to init correctly our ref grid_bound... */
 		boundInsert(&grid->grid_bounds, bData->realCoord[bData->s_pos[0]].v);
-		BLI_task_parallel_range_finalize(
-		            0, sData->total_points, bData, &grid->grid_bounds, sizeof(grid->grid_bounds),
-		            grid_bound_insert_cb_ex, grid_bound_insert_finalize, sData->total_points > 1000, false);
-
+		{
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.use_threading = (sData->total_points > 1000);
+			settings.userdata_chunk = &grid->grid_bounds;
+			settings.userdata_chunk_size = sizeof(grid->grid_bounds);
+			settings.func_finalize = grid_bound_insert_finalize;
+			BLI_task_parallel_range(
+			        0, sData->total_points,
+			        bData,
+			        grid_bound_insert_cb_ex,
+			        &settings);
+		}
 		/* get dimensions */
 		sub_v3_v3v3(dim, grid->grid_bounds.max, grid->grid_bounds.min);
 		copy_v3_v3(td, dim);
@@ -761,9 +770,19 @@ static void surfaceGenerateGrid(struct DynamicPaintSurface *surface)
 
 		if (!error) {
 			/* calculate number of points withing each cell */
-			BLI_task_parallel_range_finalize(
-			            0, sData->total_points, bData, grid->s_num, sizeof(*grid->s_num) * grid_cells,
-			            grid_cell_points_cb_ex, grid_cell_points_finalize, sData->total_points > 1000, false);
+			{
+				ParallelRangeSettings settings;
+				BLI_parallel_range_settings_defaults(&settings);
+				settings.use_threading = (sData->total_points > 1000);
+				settings.userdata_chunk = grid->s_num;
+				settings.userdata_chunk_size = sizeof(*grid->s_num) * grid_cells;
+				settings.func_finalize = grid_cell_points_finalize;
+				BLI_task_parallel_range(
+				        0, sData->total_points,
+				        bData,
+				        grid_cell_points_cb_ex,
+				        &settings);
+			}
 
 			/* calculate grid indexes (not needed for first cell, which is zero). */
 			for (i = 1; i < grid_cells; i++) {
@@ -779,7 +798,15 @@ static void surfaceGenerateGrid(struct DynamicPaintSurface *surface)
 			}
 
 			/* calculate cell bounds */
-			BLI_task_parallel_range(0, grid->dim[0], bData, grid_cell_bounds_cb, grid_cells > 1000);
+			{
+				ParallelRangeSettings settings;
+				BLI_parallel_range_settings_defaults(&settings);
+				settings.use_threading = (grid_cells > 1000);
+				BLI_task_parallel_range(0, grid->dim[0],
+				                        bData,
+				                        grid_cell_bounds_cb,
+				                        &settings);
+			}
 		}
 
 		if (temp_s_num)
@@ -1550,7 +1577,13 @@ static void dynamicPaint_setInitialColor(const Scene *scene, DynamicPaintSurface
 			    .mloop = mloop, .mlooptri = mlooptri, .mloopuv = mloopuv, .pool = pool,
 			    .scene_color_manage = scene_color_manage
 			};
-			BLI_task_parallel_range(0, tottri, &data, dynamic_paint_set_init_color_tex_to_vcol_cb, tottri > 1000);
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.use_threading = (tottri > 1000);
+			BLI_task_parallel_range(0, tottri,
+			                        &data,
+			                        dynamic_paint_set_init_color_tex_to_vcol_cb,
+			                        &settings);
 			BKE_image_pool_free(pool);
 		}
 		else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
@@ -1559,8 +1592,13 @@ static void dynamicPaint_setInitialColor(const Scene *scene, DynamicPaintSurface
 			    .mlooptri = mlooptri, .mloopuv = mloopuv,
 			    .scene_color_manage = scene_color_manage
 			};
-			BLI_task_parallel_range(0, sData->total_points, &data, dynamic_paint_set_init_color_tex_to_imseq_cb,
-			                        sData->total_points > 1000);
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.use_threading = (sData->total_points > 1000);
+			BLI_task_parallel_range(0, sData->total_points,
+			                        &data,
+			                        dynamic_paint_set_init_color_tex_to_imseq_cb,
+			                        &settings);
 		}
 	}
 	/* vertex color layer */
@@ -1588,8 +1626,13 @@ static void dynamicPaint_setInitialColor(const Scene *scene, DynamicPaintSurface
 			    .surface = surface,
 			    .mlooptri = mlooptri, .mloopcol = col,
 			};
-			BLI_task_parallel_range(0, sData->total_points, &data, dynamic_paint_set_init_color_vcol_to_imseq_cb,
-			                        sData->total_points > 1000);
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.use_threading = (sData->total_points > 1000);
+			BLI_task_parallel_range(0, sData->total_points,
+			                        &data,
+			                        dynamic_paint_set_init_color_vcol_to_imseq_cb,
+			                        &settings);
 		}
 	}
 }
@@ -1707,8 +1750,13 @@ static void dynamicPaint_applySurfaceDisplace(DynamicPaintSurface *surface, Deri
 		MVert *mvert = result->getVertArray(result);
 
 		DynamicPaintModifierApplyData data = {.surface = surface, .mvert = mvert};
-		BLI_task_parallel_range(0, sData->total_points, &data, dynamic_paint_apply_surface_displace_cb,
-		                        sData->total_points > 10000);
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (sData->total_points > 10000);
+		BLI_task_parallel_range(0, sData->total_points,
+		                        &data,
+		                        dynamic_paint_apply_surface_displace_cb,
+		                        &settings);
 	}
 }
 
@@ -1843,9 +1891,16 @@ static DerivedMesh *dynamicPaint_Modifier_apply(
 						float (*fcolor)[4] = MEM_callocN(sizeof(*fcolor) * sData->total_points, "Temp paint color");
 
 						DynamicPaintModifierApplyData data = {.surface = surface, .fcolor = fcolor};
-						BLI_task_parallel_range(0, sData->total_points, &data,
-						                        dynamic_paint_apply_surface_vpaint_blend_cb,
-						                        sData->total_points > 1000);
+						{
+							ParallelRangeSettings settings;
+							BLI_parallel_range_settings_defaults(&settings);
+							settings.use_threading = (sData->total_points > 1000);
+							BLI_task_parallel_range(
+							        0, sData->total_points,
+							        &data,
+							        dynamic_paint_apply_surface_vpaint_blend_cb,
+							        &settings);
+						}
 
 						/* paint layer */
 						MLoopCol *mloopcol = CustomData_get_layer_named(&result->loopData, CD_MLOOPCOL, surface->output_name);
@@ -1880,8 +1935,16 @@ static DerivedMesh *dynamicPaint_Modifier_apply(
 						data.mloopcol_wet = mloopcol_wet;
 						data.mloopcol_preview = mloopcol_preview;
 
-						BLI_task_parallel_range(0, totpoly, &data, dynamic_paint_apply_surface_vpaint_cb,
-						                        totpoly > 1000);
+						{
+							ParallelRangeSettings settings;
+							BLI_parallel_range_settings_defaults(&settings);
+							settings.use_threading = (totpoly > 1000);
+							BLI_task_parallel_range(
+							        0, totpoly,
+							        &data,
+							        dynamic_paint_apply_surface_vpaint_cb,
+							        &settings);
+						}
 
 						MEM_freeN(fcolor);
 
@@ -1931,8 +1994,14 @@ static DerivedMesh *dynamicPaint_Modifier_apply(
 						MVert *mvert = result->getVertArray(result);
 
 						DynamicPaintModifierApplyData data = {.surface = surface, .mvert = mvert};
-						BLI_task_parallel_range(0, sData->total_points, &data, dynamic_paint_apply_surface_wave_cb,
-						                        sData->total_points > 1000);
+						ParallelRangeSettings settings;
+						BLI_parallel_range_settings_defaults(&settings);
+						settings.use_threading = (sData->total_points > 1000);
+						BLI_task_parallel_range(
+						        0, sData->total_points,
+						        &data,
+						        dynamic_paint_apply_surface_wave_cb,
+						        &settings);
 						update_normals = true;
 					}
 
@@ -2772,7 +2841,15 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
 		    .mlooptri = mlooptri, .mloopuv = mloopuv, .mloop = mloop, .tottri = tottri,
 		    .faceBB = faceBB,
 		};
-		BLI_task_parallel_range(0, h, &data, dynamic_paint_create_uv_surface_direct_cb, h > 64 || tottri > 1000);
+		{
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.use_threading = (h > 64 || tottri > 1000);
+			BLI_task_parallel_range(0, h,
+			                        &data,
+			                        dynamic_paint_create_uv_surface_direct_cb,
+			                        &settings);
+		}
 
 		*progress = 0.04f;
 		*do_update = true;
@@ -2784,7 +2861,15 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
 		 *	(To avoid seams on uv island edges)
 		 */
 		data.active_points = &active_points;
-		BLI_task_parallel_range(0, h, &data, dynamic_paint_create_uv_surface_neighbor_cb, h > 64);
+		{
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.use_threading = (h > 64);
+			BLI_task_parallel_range(0, h,
+			                        &data,
+			                        dynamic_paint_create_uv_surface_neighbor_cb,
+			                        &settings);
+		}
 
 		*progress = 0.06f;
 		*do_update = true;
@@ -3125,13 +3210,29 @@ void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char *filenam
 		case MOD_DPAINT_SURFACE_T_PAINT:
 			switch (output_layer) {
 				case 0:
-					BLI_task_parallel_range(0, sData->total_points, &data,
-					                        dynamic_paint_output_surface_image_paint_cb, sData->total_points > 10000);
+				{
+					ParallelRangeSettings settings;
+					BLI_parallel_range_settings_defaults(&settings);
+					settings.use_threading = (sData->total_points > 10000);
+					BLI_task_parallel_range(
+					        0, sData->total_points,
+					        &data,
+					        dynamic_paint_output_surface_image_paint_cb,
+					        &settings);
 					break;
+				}
 				case 1:
-					BLI_task_parallel_range(0, sData->total_points, &data,
-					                        dynamic_paint_output_surface_image_wetmap_cb, sData->total_points > 10000);
+				{
+					ParallelRangeSettings settings;
+					BLI_parallel_range_settings_defaults(&settings);
+					settings.use_threading = (sData->total_points > 10000);
+					BLI_task_parallel_range(
+					        0, sData->total_points,
+					        &data,
+					        dynamic_paint_output_surface_image_wetmap_cb,
+					        &settings);
 					break;
+				}
 				default:
 					BLI_assert(0);
 					break;
@@ -3140,9 +3241,17 @@ void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char *filenam
 		case MOD_DPAINT_SURFACE_T_DISPLACE:
 			switch (output_layer) {
 				case 0:
-					BLI_task_parallel_range(0, sData->total_points, &data,
-					                        dynamic_paint_output_surface_image_displace_cb, sData->total_points > 10000);
+				{
+					ParallelRangeSettings settings;
+					BLI_parallel_range_settings_defaults(&settings);
+					settings.use_threading = (sData->total_points > 10000);
+					BLI_task_parallel_range(
+					        0, sData->total_points,
+					        &data,
+					        dynamic_paint_output_surface_image_displace_cb,
+					        &settings);
 					break;
+				}
 				case 1:
 					break;
 				default:
@@ -3153,9 +3262,17 @@ void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char *filenam
 		case MOD_DPAINT_SURFACE_T_WAVE:
 			switch (output_layer) {
 				case 0:
-					BLI_task_parallel_range(0, sData->total_points, &data,
-					                        dynamic_paint_output_surface_image_wave_cb, sData->total_points > 10000);
+				{
+					ParallelRangeSettings settings;
+					BLI_parallel_range_settings_defaults(&settings);
+					settings.use_threading = (sData->total_points > 10000);
+					BLI_task_parallel_range(
+					        0, sData->total_points,
+					        &data,
+					        dynamic_paint_output_surface_image_wave_cb,
+					        &settings);
 					break;
+				}
 				case 1:
 					break;
 				default:
@@ -3642,7 +3759,13 @@ static void dynamicPaint_brushMeshCalculateVelocity(
 		.mvert_p = mvert_p, .mvert_c = mvert_c, .obmat = ob->obmat, .prev_obmat = prev_obmat,
 		.timescale = timescale,
 	};
-	BLI_task_parallel_range(0, numOfVerts_c, &data, dynamic_paint_brush_velocity_compute_cb, numOfVerts_c > 10000);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (numOfVerts_c > 10000);
+	BLI_task_parallel_range(0, numOfVerts_c,
+	                        &data,
+	                        dynamic_paint_brush_velocity_compute_cb,
+	                        &settings);
 
 	dm_p->release(dm_p);
 }
@@ -4131,9 +4254,13 @@ static int dynamicPaint_paintMesh(DynamicPaintSurface *surface,
 					    .brush_radius = brush_radius, .avg_brushNor = avg_brushNor, .brushVelocity = brushVelocity,
 					    .treeData = &treeData
 					};
-					BLI_task_parallel_range_ex(0, grid->s_num[c_index], &data, NULL, 0,
-					                           dynamic_paint_paint_mesh_cell_point_cb_ex,
-					                           grid->s_num[c_index] > 250, true);
+					ParallelRangeSettings settings;
+					BLI_parallel_range_settings_defaults(&settings);
+					settings.use_threading = (grid->s_num[c_index] > 250);
+					BLI_task_parallel_range(0, grid->s_num[c_index],
+					                        &data,
+					                        dynamic_paint_paint_mesh_cell_point_cb_ex,
+					                        &settings);
 				}
 			}
 		}
@@ -4416,9 +4543,13 @@ static int dynamicPaint_paintParticles(DynamicPaintSurface *surface,
 			    .solidradius = solidradius, .timescale = timescale, .c_index = c_index,
 			    .treeData = tree,
 			};
-			BLI_task_parallel_range_ex(0, grid->s_num[c_index], &data, NULL, 0,
-			                           dynamic_paint_paint_particle_cell_point_cb_ex,
-			                           grid->s_num[c_index] > 250, true);
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.use_threading = (grid->s_num[c_index] > 250);
+			BLI_task_parallel_range(0, grid->s_num[c_index],
+			                        &data,
+			                        dynamic_paint_paint_particle_cell_point_cb_ex,
+			                        &settings);
 		}
 	}
 	BLI_end_threaded_malloc();
@@ -4561,9 +4692,13 @@ static int dynamicPaint_paintSinglePoint(
 	    .brush_radius = brush_radius, .brushVelocity = &brushVel,
 	    .pointCoord = pointCoord,
 	};
-	BLI_task_parallel_range_ex(0, sData->total_points, &data, NULL, 0,
-	                           dynamic_paint_paint_single_point_cb_ex,
-	                           sData->total_points > 1000, true);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (sData->total_points > 1000);
+	BLI_task_parallel_range(0, sData->total_points,
+	                        &data,
+	                        dynamic_paint_paint_single_point_cb_ex,
+	                        &settings);
 
 	return 1;
 }
@@ -4615,8 +4750,13 @@ static void dynamicPaint_prepareAdjacencyData(DynamicPaintSurface *surface, cons
 	if (!bNeighs)
 		return;
 
-	BLI_task_parallel_range(
-	            0, sData->total_points, sData, dynamic_paint_prepare_adjacency_cb, sData->total_points > 1000);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (sData->total_points > 1000);
+	BLI_task_parallel_range(0, sData->total_points,
+	                        sData,
+	                        dynamic_paint_prepare_adjacency_cb,
+	                        &settings);
 
 	/* calculate average values (single thread).
 	 * Note: tried to put this in threaded callback (using _finalize feature), but gave ~30% slower result! */
@@ -4876,8 +5016,13 @@ static int dynamicPaint_prepareEffectStep(
 				.surface = surface, .scene = scene,
 				.force = *force, .effectors = effectors,
 			};
-			BLI_task_parallel_range(
-			            0, sData->total_points, &data, dynamic_paint_prepare_effect_cb, sData->total_points > 1000);
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.use_threading = (sData->total_points > 1000);
+			BLI_task_parallel_range(0, sData->total_points,
+			                        &data,
+			                        dynamic_paint_prepare_effect_cb,
+			                        &settings);
 
 			/* calculate average values (single thread) */
 			for (int index = 0; index < sData->total_points; index++) {
@@ -5140,8 +5285,13 @@ static void dynamicPaint_doEffectStep(
 		DynamicPaintEffectData data = {
 			.surface = surface, .prevPoint = prevPoint, .eff_scale = eff_scale,
 		};
-		BLI_task_parallel_range(
-		            0, sData->total_points, &data, dynamic_paint_effect_spread_cb, sData->total_points > 1000);
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (sData->total_points > 1000);
+		BLI_task_parallel_range(0, sData->total_points,
+		                        &data,
+		                        dynamic_paint_effect_spread_cb,
+		                        &settings);
 	}
 
 	/*
@@ -5156,8 +5306,13 @@ static void dynamicPaint_doEffectStep(
 		DynamicPaintEffectData data = {
 			.surface = surface, .prevPoint = prevPoint, .eff_scale = eff_scale,
 		};
-		BLI_task_parallel_range(
-		            0, sData->total_points, &data, dynamic_paint_effect_shrink_cb, sData->total_points > 1000);
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (sData->total_points > 1000);
+		BLI_task_parallel_range(0, sData->total_points,
+		                        &data,
+		                        dynamic_paint_effect_shrink_cb,
+		                        &settings);
 	}
 
 	/*
@@ -5178,8 +5333,13 @@ static void dynamicPaint_doEffectStep(
 		    .eff_scale = eff_scale, .force = force,
 		    .point_locks = point_locks,
 		};
-		BLI_task_parallel_range(
-		            0, sData->total_points, &data, dynamic_paint_effect_drip_cb, sData->total_points > 1000);
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (sData->total_points > 1000);
+		BLI_task_parallel_range(0, sData->total_points,
+		                        &data,
+		                        dynamic_paint_effect_drip_cb,
+		                        &settings);
 
 		MEM_freeN(point_locks);
 	}
@@ -5256,8 +5416,13 @@ static void dynamicPaint_doBorderStep(DynamicPaintSurface *surface)
 		.surface = surface
 	};
 
-	BLI_task_parallel_range(
-	            0, sData->adj_data->total_border, &data, dynamic_paint_border_cb, sData->adj_data->total_border > 1000);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (sData->adj_data->total_border > 1000);
+	BLI_task_parallel_range(0, sData->adj_data->total_border,
+	                        &data,
+	                        dynamic_paint_border_cb,
+	                        &settings);
 }
 
 static void dynamic_paint_wave_step_cb(void *userdata, const int index,
@@ -5403,8 +5568,12 @@ static void dynamicPaint_doWaveStep(DynamicPaintSurface *surface, float timescal
 		    .wave_speed = wave_speed, .wave_scale = wave_scale, .wave_max_slope = wave_max_slope,
 		    .dt = dt, .min_dist = min_dist, .damp_factor = damp_factor, .reset_wave = (ss == steps - 1),
 		};
-		BLI_task_parallel_range(
-		            0, sData->total_points, &data, dynamic_paint_wave_step_cb, sData->total_points > 1000);
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (sData->total_points > 1000);
+		BLI_task_parallel_range(0, sData->total_points,
+		                        &data, dynamic_paint_wave_step_cb,
+		                        &settings);
 	}
 
 	MEM_freeN(prevPoint);
@@ -5753,8 +5922,13 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, const Sce
 	    .mvert = mvert, .canvas_verts = canvas_verts,
 	    .do_velocity_data = do_velocity_data, .new_bdata = new_bdata,
 	};
-	BLI_task_parallel_range(
-	            0, sData->total_points, &data, dynamic_paint_generate_bake_data_cb, sData->total_points > 1000);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (sData->total_points > 1000);
+	BLI_task_parallel_range(0, sData->total_points,
+	                        &data,
+	                        dynamic_paint_generate_bake_data_cb,
+	                        &settings);
 
 	MEM_freeN(canvas_verts);
 
@@ -5787,8 +5961,13 @@ static int dynamicPaint_doStep(Scene *scene, Object *ob, DynamicPaintSurface *su
 
 	if (dynamic_paint_surface_needs_dry_dissolve(surface)) {
 		DynamicPaintDissolveDryData data = {.surface = surface, .timescale = timescale};
-		BLI_task_parallel_range(0, sData->total_points, &data,
-		                        dynamic_paint_surface_pre_step_cb, sData->total_points > 1000);
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (sData->total_points > 1000);
+		BLI_task_parallel_range(0, sData->total_points,
+		                        &data,
+		                        dynamic_paint_surface_pre_step_cb,
+		                        &settings);
 	}
 
 	/*
diff --git a/source/blender/blenkernel/intern/mask_rasterize.c b/source/blender/blenkernel/intern/mask_rasterize.c
index 489f1965884..6efcb27c0f5 100644
--- a/source/blender/blenkernel/intern/mask_rasterize.c
+++ b/source/blender/blenkernel/intern/mask_rasterize.c
@@ -1475,5 +1475,11 @@ void BKE_maskrasterize_buffer(MaskRasterHandle *mr_handle,
 	    .width = width,
 	    .buffer = buffer
 	};
-	BLI_task_parallel_range(0, (int)height, &data, maskrasterize_buffer_cb, height * width > 10000);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = ((size_t)height * width > 10000);
+	BLI_task_parallel_range(0, (int)height,
+	                        &data,
+	                        maskrasterize_buffer_cb,
+	                        &settings);
 }
diff --git a/source/blender/blenkernel/intern/mesh_evaluate.c b/source/blender/blenkernel/intern/mesh_evaluate.c
index b58bea941e5..c1beaaaac75 100644
--- a/source/blender/blenkernel/intern/mesh_evaluate.c
+++ b/source/blender/blenkernel/intern/mesh_evaluate.c
@@ -282,6 +282,10 @@ void BKE_mesh_calc_normals_poly(
 	const bool do_threaded = (numPolys > BKE_MESH_OMP_LIMIT);
 	float (*pnors)[3] = r_polynors;
 
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = do_threaded;
+
 	if (only_face_normals) {
 		BLI_assert((pnors != NULL) || (numPolys == 0));
 		BLI_assert(r_vertnors == NULL);
@@ -290,7 +294,7 @@ void BKE_mesh_calc_normals_poly(
 		    .mpolys = mpolys, .mloop = mloop, .mverts = mverts, .pnors = pnors,
 		};
 
-		BLI_task_parallel_range(0, numPolys, &data, mesh_calc_normals_poly_cb, do_threaded);
+		BLI_task_parallel_range(0, numPolys, &data, mesh_calc_normals_poly_cb, &settings);
 		return;
 	}
 
@@ -313,13 +317,13 @@ void BKE_mesh_calc_normals_poly(
 	};
 
 	/* Compute poly normals, and prepare weighted loop normals. */
-	BLI_task_parallel_range(0, numPolys, &data, mesh_calc_normals_poly_prepare_cb, do_threaded);
+	BLI_task_parallel_range(0, numPolys, &data, mesh_calc_normals_poly_prepare_cb, &settings);
 
 	/* Actually accumulate weighted loop normals into vertex ones. */
-	BLI_task_parallel_range(0, numLoops, &data, mesh_calc_normals_poly_accum_cb, do_threaded);
+	BLI_task_parallel_range(0, numLoops, &data, mesh_calc_normals_poly_accum_cb, &settings);
 
 	/* Normalize and validate computed vertex normals. */
-	BLI_task_parallel_range(0, numVerts, &data, mesh_calc_normals_poly_finalize_cb, do_threaded);
+	BLI_task_parallel_range(0, numVerts, &data, mesh_calc_normals_poly_finalize_cb, &settings);
 
 	if (free_vnors) {
 		MEM_freeN(vnors);
diff --git a/source/blender/blenkernel/intern/ocean.c b/source/blender/blenkernel/intern/ocean.c
index 53e4119987f..478b7ef21ef 100644
--- a/source/blender/blenkernel/intern/ocean.c
+++ b/source/blender/blenkernel/intern/ocean.c
@@ -749,7 +749,10 @@ void BKE_ocean_simulate(struct Ocean *o, float t, float scale, float chop_amount
 	 * This is not optimal in all cases, but remains reasonably simple and should be OK most of the time. */
 
 	/* compute a new htilda */
-	BLI_task_parallel_range(0, o->_M, &osd, ocean_compute_htilda, o->_M > 16);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (o->_M > 16);
+	BLI_task_parallel_range(0, o->_M, &osd, ocean_compute_htilda, &settings);
 
 	if (o->_do_disp_y) {
 		BLI_task_pool_push(pool, ocean_compute_displacement_y, NULL, false, TASK_PRIORITY_HIGH);
diff --git a/source/blender/blenkernel/intern/particle_system.c b/source/blender/blenkernel/intern/particle_system.c
index 505f6c63baf..628939c6c18 100644
--- a/source/blender/blenkernel/intern/particle_system.c
+++ b/source/blender/blenkernel/intern/particle_system.c
@@ -3637,9 +3637,16 @@ static void dynamics_step(ParticleSimulationData *sim, float cfra)
 				/* Apply SPH forces using double-density relaxation algorithm
 				 * (Clavat et. al.) */
 
-				BLI_task_parallel_range_ex(
-				            0, psys->totpart, &task_data, &sphdata, sizeof(sphdata),
-				            dynamics_step_sph_ddr_task_cb_ex, psys->totpart > 100, true);
+				ParallelRangeSettings settings;
+				BLI_parallel_range_settings_defaults(&settings);
+				settings.use_threading = (psys->totpart > 100);
+				settings.userdata_chunk = &sphdata;
+				settings.userdata_chunk_size = sizeof(sphdata);
+				BLI_task_parallel_range(
+				        0, psys->totpart,
+				        &task_data,
+				        dynamics_step_sph_ddr_task_cb_ex,
+				        &settings);
 
 				sph_springs_modify(psys, timestep);
 			}
@@ -3649,21 +3656,46 @@ static void dynamics_step(ParticleSimulationData *sim, float cfra)
 				 * and Monaghan). Note that, unlike double-density relaxation,
 				 * this algorithm is separated into distinct loops. */
 
-				BLI_task_parallel_range_ex(
-				            0, psys->totpart, &task_data, NULL, 0,
-				            dynamics_step_sph_classical_basic_integrate_task_cb_ex, psys->totpart > 100, true);
+				{
+					ParallelRangeSettings settings;
+					BLI_parallel_range_settings_defaults(&settings);
+					settings.use_threading = (psys->totpart > 100);
+					BLI_task_parallel_range(
+					        0, psys->totpart,
+					        &task_data,
+					        dynamics_step_sph_classical_basic_integrate_task_cb_ex,
+					        &settings);
+				}
 
 				/* calculate summation density */
 				/* Note that we could avoid copying sphdata for each thread here (it's only read here),
 				 * but doubt this would gain us anything except confusion... */
-				BLI_task_parallel_range_ex(
-				            0, psys->totpart, &task_data, &sphdata, sizeof(sphdata),
-				            dynamics_step_sph_classical_calc_density_task_cb_ex, psys->totpart > 100, true);
+				{
+				ParallelRangeSettings settings;
+				BLI_parallel_range_settings_defaults(&settings);
+				settings.use_threading = (psys->totpart > 100);
+				settings.userdata_chunk = &sphdata;
+				settings.userdata_chunk_size = sizeof(sphdata);
+					BLI_task_parallel_range(
+					        0, psys->totpart,
+					        &task_data,
+					        dynamics_step_sph_classical_calc_density_task_cb_ex,
+					        &settings);
+				}
 
 				/* do global forces & effectors */
-				BLI_task_parallel_range_ex(
-				            0, psys->totpart, &task_data, &sphdata, sizeof(sphdata),
-				            dynamics_step_sph_classical_integrate_task_cb_ex, psys->totpart > 100, true);
+				{
+				ParallelRangeSettings settings;
+				BLI_parallel_range_settings_defaults(&settings);
+				settings.use_threading = (psys->totpart > 100);
+				settings.userdata_chunk = &sphdata;
+				settings.userdata_chunk_size = sizeof(sphdata);
+					BLI_task_parallel_range(
+					        0, psys->totpart,
+					        &task_data,
+					        dynamics_step_sph_classical_integrate_task_cb_ex,
+					        &settings);
+				}
 			}
 
 			BLI_spin_end(&task_data.spin);
diff --git a/source/blender/blenkernel/intern/pbvh.c b/source/blender/blenkernel/intern/pbvh.c
index e476ccbc48b..43ea1ad83a0 100644
--- a/source/blender/blenkernel/intern/pbvh.c
+++ b/source/blender/blenkernel/intern/pbvh.c
@@ -1052,9 +1052,13 @@ static void pbvh_update_normals(PBVH *bvh, PBVHNode **nodes,
 	    .fnors = fnors, .vnors = vnors,
 	};
 
-	BLI_task_parallel_range(0, totnode, &data, pbvh_update_normals_accum_task_cb, totnode > PBVH_THREADED_LIMIT);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (totnode > PBVH_THREADED_LIMIT);
 
-	BLI_task_parallel_range(0, totnode, &data, pbvh_update_normals_store_task_cb, totnode > PBVH_THREADED_LIMIT);
+	BLI_task_parallel_range(0, totnode, &data, pbvh_update_normals_accum_task_cb, &settings);
+
+	BLI_task_parallel_range(0, totnode, &data, pbvh_update_normals_store_task_cb, &settings);
 
 	MEM_freeN(vnors);
 }
@@ -1087,7 +1091,10 @@ void pbvh_update_BB_redraw(PBVH *bvh, PBVHNode **nodes, int totnode, int flag)
 	    .flag = flag,
 	};
 
-	BLI_task_parallel_range(0, totnode, &data, pbvh_update_BB_redraw_task_cb, totnode > PBVH_THREADED_LIMIT);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (totnode > PBVH_THREADED_LIMIT);
+	BLI_task_parallel_range(0, totnode, &data, pbvh_update_BB_redraw_task_cb, &settings);
 }
 
 static void pbvh_update_draw_buffers(PBVH *bvh, PBVHNode **nodes, int totnode)
diff --git a/source/blender/blenkernel/intern/shrinkwrap.c b/source/blender/blenkernel/intern/shrinkwrap.c
index 09b0dc569cb..0f12bb0a8da 100644
--- a/source/blender/blenkernel/intern/shrinkwrap.c
+++ b/source/blender/blenkernel/intern/shrinkwrap.c
@@ -167,9 +167,14 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
 	nearest.dist_sq = FLT_MAX;
 
 	ShrinkwrapCalcCBData data = {.calc = calc, .treeData = &treeData};
-	BLI_task_parallel_range_ex(
-	            0, calc->numVerts, &data, &nearest, sizeof(nearest), shrinkwrap_calc_nearest_vertex_cb_ex,
-	            calc->numVerts > BKE_MESH_OMP_LIMIT, false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (calc->numVerts > BKE_MESH_OMP_LIMIT);
+	settings.userdata_chunk = &nearest;
+	settings.userdata_chunk_size = sizeof(nearest);
+	BLI_task_parallel_range(0, calc->numVerts,
+	                        &data,shrinkwrap_calc_nearest_vertex_cb_ex,
+	                        &settings);
 
 	free_bvhtree_from_mesh(&treeData);
 }
@@ -463,9 +468,15 @@ static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc, bool for
 			.auxData = auxData, .aux_tree = aux_tree, .aux_callback = aux_callback,
 			.proj_axis = proj_axis, .local2aux = &local2aux,
 		};
-		BLI_task_parallel_range_ex(
-		            0, calc->numVerts, &data, &hit, sizeof(hit), shrinkwrap_calc_normal_projection_cb_ex,
-		            calc->numVerts > BKE_MESH_OMP_LIMIT, false);
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.use_threading = (calc->numVerts > BKE_MESH_OMP_LIMIT);
+		settings.userdata_chunk = &hit;
+		settings.userdata_chunk_size = sizeof(hit);
+		BLI_task_parallel_range(0, calc->numVerts,
+		                        &data,
+		                        shrinkwrap_calc_normal_projection_cb_ex,
+		                        &settings);
 	}
 
 	/* free data structures */
@@ -583,9 +594,15 @@ static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
 
 	/* Find the nearest vertex */
 	ShrinkwrapCalcCBData data = {.calc = calc, .treeData = &treeData};
-	BLI_task_parallel_range_ex(
-	            0, calc->numVerts, &data, &nearest, sizeof(nearest), shrinkwrap_calc_nearest_surface_point_cb_ex,
-	            calc->numVerts > BKE_MESH_OMP_LIMIT, false);
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (calc->numVerts > BKE_MESH_OMP_LIMIT);
+	settings.userdata_chunk = &nearest;
+	settings.userdata_chunk_size = sizeof(nearest);
+	BLI_task_parallel_range(0, calc->numVerts,
+	                        &data,
+	                        shrinkwrap_calc_nearest_surface_point_cb_ex,
+	                        &settings);
 
 	free_bvhtree_from_mesh(&treeData);
 }
diff --git a/source/blender/blenkernel/intern/smoke.c b/source/blender/blenkernel/intern/smoke.c
index 37b9466645d..9c245b444ee 100644
--- a/source/blender/blenkernel/intern/smoke.c
+++ b/source/blender/blenkernel/intern/smoke.c
@@ -868,8 +868,13 @@ static void obstacles_from_derivedmesh(
 			    .velocityX = velocityX, .velocityY = velocityY, .velocityZ = velocityZ,
 			    .num_obstacles = num_obstacles
 			};
-			BLI_task_parallel_range(
-			            sds->res_min[2], sds->res_max[2], &data, obstacles_from_derivedmesh_task_cb, true);
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
+			BLI_task_parallel_range(sds->res_min[2], sds->res_max[2],
+			                        &data,
+			                        obstacles_from_derivedmesh_task_cb,
+			                        &settings);
 		}
 		/* free bvh tree */
 		free_bvhtree_from_mesh(&treeData);
@@ -1395,7 +1400,13 @@ static void emit_from_particles(
 			    .solid = solid, .smooth = smooth, .hr_smooth = hr_smooth,
 			};
 
-			BLI_task_parallel_range(min[2], max[2], &data, emit_from_particles_task_cb, true);
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
+			BLI_task_parallel_range(min[2], max[2],
+			                        &data,
+			                        emit_from_particles_task_cb,
+			                        &settings);
 		}
 
 		if (sfs->flags & MOD_SMOKE_FLOW_USE_PART_SIZE) {
@@ -1720,7 +1731,13 @@ static void emit_from_derivedmesh(Object *flow_ob, SmokeDomainSettings *sds, Smo
 			    .flow_center = flow_center, .min = min, .max = max, .res = res,
 			};
 
-			BLI_task_parallel_range(min[2], max[2], &data, emit_from_derivedmesh_task_cb, true);
+			ParallelRangeSettings settings;
+			BLI_parallel_range_settings_defaults(&settings);
+			settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
+			BLI_task_parallel_range(min[2], max[2],
+			                        &data,
+			                        emit_from_derivedmesh_task_cb,
+			                        &settings);
 		}
 		/* free bvh tree */
 		free_bvhtree_from_mesh(&treeData);
@@ -2510,7 +2527,13 @@ static void update_effectors(Scene *scene, Object *ob, SmokeDomainSettings *sds,
 		data.velocity_z = smoke_get_velocity_z(sds->fluid);
 		data.obstacle = smoke_get_obstacle(sds->fluid);
 
-		BLI_task_parallel_range(0, sds->res[0], &data, update_effectors_task_cb, true);
+		ParallelRangeSettings settings;
+		BLI_parallel_range_settings_defaults(&settings);
+		settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
+		BLI_task_parallel_range(0, sds->res[0],
+		                        &data,
+		                        update_effectors_task_cb,
+		                        &settings);
 	}
 
 	pdEndEffectors(&effectors);
diff --git a/source/blender/blenkernel/intern/tracking_auto.c b/source/blender/blenkernel/intern/tracking_auto.c
index 5dc350640c0..0874d645a34 100644
--- a/source/blender/blenkernel/intern/tracking_auto.c
+++ b/source/blender/blenkernel/intern/tracking_auto.c
@@ -512,10 +512,13 @@ bool BKE_autotrack_context_step(AutoTrackContext *context)
 	const int frame_delta = context->backwards ? -1 : 1;
 	context->step_ok = false;
 
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (context->num_tracks > 1);
 	BLI_task_parallel_range(0, context->num_tracks,
 	                        context,
 	                        autotrack_context_step_cb,
-	                        context->num_tracks > 1);
+	                        &settings);
 
 	/* Advance the frame. */
 	BLI_spin_lock(&context->spin_lock);
diff --git a/source/blender/blenkernel/intern/tracking_stabilize.c b/source/blender/blenkernel/intern/tracking_stabilize.c
index 9e8f01df1d5..fe850708547 100644
--- a/source/blender/blenkernel/intern/tracking_stabilize.c
+++ b/source/blender/blenkernel/intern/tracking_stabilize.c
@@ -1600,10 +1600,14 @@ ImBuf *BKE_tracking_stabilize_frame(MovieClip *clip,
 		.ibuf = ibuf, .tmpibuf = tmpibuf, .mat = mat,
 		.interpolation = interpolation
 	};
+
+	ParallelRangeSettings settings;
+	BLI_parallel_range_settings_defaults(&settings);
+	settings.use_threading = (tmpibuf->y > 128);
 	BLI_task_parallel_range(0, tmpibuf->y,
 	                        &data,
 	                        tracking_stabilize_frame_interpolation_cb,
-	                        tmpibuf->y > 128);
+	                        &settings);
 
 	if (tmpibuf->rect_float)
 		tmpibuf->userflags |= IB_RECT_INVALID;