Style cleanup of own modules using style checker from Campbell.

1 files changed, 87 insertions, 74 deletions

diff --git a/source/blender/blenkernel/intern/tracking.c b/source/blender/blenkernel/intern/tracking.c
index b68102885ea..b27a065730b 100644
--- a/source/blender/blenkernel/intern/tracking.c
+++ b/source/blender/blenkernel/intern/tracking.c
@@ -166,11 +166,11 @@ void BKE_tracking_clamp_track(MovieTrackingTrack *track, int event)
 			/* search shouldn't be moved inside pattern */
 			if (track->search_min[a] > pat_min[a]) {
 				track->search_min[a] = pat_min[a];
-				track->search_max[a] = track->search_min[a]+dim[a];
+				track->search_max[a] = track->search_min[a] + dim[a];
 			}
 			if (track->search_max[a] < pat_max[a]) {
 				track->search_max[a] = pat_max[a];
-				track->search_min[a] = track->search_max[a]-dim[a];
+				track->search_min[a] = track->search_max[a] - dim[a];
 			}
 		}
 	}
@@ -196,8 +196,8 @@ void BKE_tracking_clamp_track(MovieTrackingTrack *track, int event)
 		sub_v2_v2v2(dim, track->pat_max, track->pat_min);
 
 		for (a = 0; a < 2; a++) {
-			track->pat_min[a] = -dim[a]/2.0f;
-			track->pat_max[a] = dim[a]/2.0f;
+			track->pat_min[a] = -dim[a] / 2.0f;
+			track->pat_max[a] = dim[a] / 2.0f;
 		}
 	}
 }
@@ -302,8 +302,9 @@ MovieTrackingMarker *BKE_tracking_insert_marker(MovieTrackingTrack *track, Movie
 		else
 			track->markers = MEM_callocN(sizeof(MovieTrackingMarker), "MovieTracking markers");
 
-		memmove(track->markers+a+2, track->markers+a+1, (track->markersnr-a-2)*sizeof(MovieTrackingMarker));
-		track->markers[a+1] = *marker;
+		memmove(track->markers + a + 2, track->markers + a + 1,
+		        (track->markersnr - a - 2) * sizeof(MovieTrackingMarker));
+		track->markers[a + 1] = *marker;
 
 		track->last_marker = a + 1;
 
@@ -315,12 +316,13 @@ void BKE_tracking_delete_marker(MovieTrackingTrack *track, int framenr)
 {
 	int a = 0;
 
-	while (a<track->markersnr) {
+	while (a < track->markersnr) {
 		if (track->markers[a].framenr == framenr) {
 			if (track->markersnr > 1) {
-				memmove(track->markers+a, track->markers+a+1, (track->markersnr-a-1)*sizeof(MovieTrackingMarker));
+				memmove(track->markers + a, track->markers + a + 1,
+				        (track->markersnr - a - 1) * sizeof(MovieTrackingMarker));
 				track->markersnr--;
-				track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker)*track->markersnr);
+				track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker) * track->markersnr);
 			}
 			else {
 				MEM_freeN(track->markers);
@@ -337,7 +339,7 @@ void BKE_tracking_delete_marker(MovieTrackingTrack *track, int framenr)
 
 MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int framenr)
 {
-	int a = track->markersnr-1;
+	int a = track->markersnr - 1;
 
 	if (!track->markersnr)
 		return NULL;
@@ -360,7 +362,7 @@ MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int fram
 		}
 
 		/* if there's no marker for exact position, use nearest marker from left side */
-		return &track->markers[a-1];
+		return &track->markers[a - 1];
 	}
 	else {
 		while (a >= 0 && track->markers[a].framenr >= framenr) {
@@ -461,16 +463,16 @@ void BKE_tracking_clear_path(MovieTrackingTrack *track, int ref_frame, int actio
 		}
 
 		if (track->markersnr)
-			put_disabled_marker(track, &track->markers[track->markersnr-1], 0, 1);
+			put_disabled_marker(track, &track->markers[track->markersnr - 1], 0, 1);
 	}
 	else if (action == TRACK_CLEAR_UPTO) {
-		a = track->markersnr-1;
+		a = track->markersnr - 1;
 
 		while (a >= 0) {
 			if (track->markers[a].framenr <= ref_frame) {
-				memmove(track->markers, track->markers+a, (track->markersnr-a)*sizeof(MovieTrackingMarker));
+				memmove(track->markers, track->markers + a, (track->markersnr - a) * sizeof(MovieTrackingMarker));
 
-				track->markersnr = track->markersnr-a;
+				track->markersnr = track->markersnr - a;
 				track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker)*track->markersnr);
 
 				break;
@@ -521,8 +523,8 @@ void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack
 			markers[i] = dst_track->markers[b++];
 		}
 		else {
-			if ((src_track->markers[a].flag & MARKER_DISABLED)==0) {
-				if ((dst_track->markers[b].flag & MARKER_DISABLED)==0) {
+			if ((src_track->markers[a].flag & MARKER_DISABLED) == 0) {
+				if ((dst_track->markers[b].flag & MARKER_DISABLED) == 0) {
 					/* both tracks are enabled on this frame, so find the whole segment
 					 * on which tracks are intersecting and blend tracks using linear
 					 * interpolation to prevent jumps */
@@ -532,8 +534,8 @@ void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack
 					int j, inverse = 0;
 
 					inverse = (b == 0) ||
-					          (dst_track->markers[b-1].flag & MARKER_DISABLED) ||
-					          (dst_track->markers[b-1].framenr != frame - 1);
+					          (dst_track->markers[b - 1].flag & MARKER_DISABLED) ||
+					          (dst_track->markers[b - 1].framenr != frame - 1);
 
 					/* find length of intersection */
 					while (a < src_track->markersnr && b < dst_track->markersnr) {
@@ -969,7 +971,7 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 	/* count */
 	track = tracksbase->first;
 	while (track) {
-		if (TRACK_SELECTED(track) && (track->flag & (TRACK_LOCKED | TRACK_HIDDEN))==0) {
+		if (TRACK_SELECTED(track) && (track->flag & (TRACK_LOCKED | TRACK_HIDDEN)) == 0) {
 			MovieTrackingMarker *marker = BKE_tracking_get_marker(track, user->framenr);
 
 			if ((marker->flag & MARKER_DISABLED) == 0)
@@ -1000,13 +1002,13 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 
 #ifdef WITH_LIBMV
 					{
-						float patx = (int)((track->pat_max[0]-track->pat_min[0])*width),
-						      paty = (int)((track->pat_max[1]-track->pat_min[1])*height);
+						float patx = (int)((track->pat_max[0] - track->pat_min[0]) * width),
+						      paty = (int)((track->pat_max[1] - track->pat_min[1]) * height);
 
-						float search_size_x = (track->search_max[0]-track->search_min[0])*width;
-						float search_size_y = (track->search_max[1]-track->search_min[1])*height;
-						float pattern_size_x = (track->pat_max[0]-track->pat_min[0])*width;
-						float pattern_size_y = (track->pat_max[1]-track->pat_min[1])*height;
+						float search_size_x = (track->search_max[0] - track->search_min[0]) * width;
+						float search_size_y = (track->search_max[1] - track->search_min[1]) * height;
+						float pattern_size_x = (track->pat_max[0] - track->pat_min[0]) * width;
+						float pattern_size_y = (track->pat_max[1] - track->pat_min[1]) * height;
 						int wndx = (int)patx / 2, wndy = (int)paty / 2;
 						int half_wnd = MAX2(wndx, wndy);
 
@@ -1021,17 +1023,20 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 						 * than the search size */
 						int level = MIN2(track->pyramid_levels, max_pyramid_levels);
 
+						struct libmv_RegionTracker *region_tracker;
+
 						if (track->tracker == TRACKER_KLT) {
-							track_context.region_tracker =
-								libmv_pyramidRegionTrackerNew(100, level, half_wnd, track->minimum_correlation);
+							region_tracker = libmv_pyramidRegionTrackerNew(100, level, half_wnd,
+							                                               track->minimum_correlation);
 						}
 						else if (track->tracker == TRACKER_HYBRID) {
-							track_context.region_tracker =
-								libmv_hybridRegionTrackerNew(100, half_wnd, track->minimum_correlation);
+							region_tracker = libmv_hybridRegionTrackerNew(100, half_wnd, track->minimum_correlation);
 						}
 						else if (track->tracker == TRACKER_SAD) {
-							track_context.region_tracker = libmv_bruteRegionTrackerNew(MAX2(wndx, wndy), track->minimum_correlation);
+							region_tracker = libmv_bruteRegionTrackerNew(MAX2(wndx, wndy), track->minimum_correlation);
 						}
+
+						track_context.region_tracker = region_tracker;
 					}
 #endif
 
@@ -1094,7 +1099,8 @@ void BKE_tracking_context_free(MovieTrackingContext *context)
 /* zap channels from the imbuf that are disabled by the user. this can lead to
  * better tracks sometimes. however, instead of simply zeroing the channels
  * out, do a partial grayscale conversion so the display is better. */
-void BKE_tracking_disable_imbuf_channels(ImBuf *ibuf, int disable_red, int disable_green, int disable_blue, int grayscale)
+void BKE_tracking_disable_imbuf_channels(ImBuf *ibuf, int disable_red, int disable_green, int disable_blue,
+                                         int grayscale)
 {
 	int x, y;
 	float scale;
@@ -1181,13 +1187,13 @@ static ImBuf *get_area_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTracki
 	h = (max[1] - min[1]) * ibuf->y;
 
 	/* dimensions should be odd */
-	w = w|1;
-	h = h|1;
+	w = w | 1;
+	h = h | 1;
 
-	x1 = x-(int)(w * (-min[0] / (max[0] - min[0])));
-	y1 = y-(int)(h * (-min[1] / (max[1] - min[1])));
+	x1 = x - (int)(w * (-min[0] / (max[0] - min[0])));
+	y1 = y - (int)(h * (-min[1] / (max[1] - min[1])));
 
-	tmpibuf = IMB_allocImBuf(w+margin*2, h+margin*2, 32, IB_rect);
+	tmpibuf = IMB_allocImBuf(w + margin * 2, h + margin * 2, 32, IB_rect);
 	IMB_rectcpy(tmpibuf, ibuf, 0, 0, x1 - margin, y1 - margin, w + margin * 2, h + margin * 2);
 
 	if (pos != NULL) {
@@ -1310,17 +1316,17 @@ static ImBuf *get_keyframed_ibuf(MovieTrackingContext *context, MovieTrackingTra
                                  MovieTrackingMarker *marker, MovieTrackingMarker **marker_keyed)
 {
 	int framenr = marker->framenr;
-	int a = marker-track->markers;
+	int a = marker - track->markers;
 
 	*marker_keyed = marker;
 
 	while (a >= 0 && a < track->markersnr) {
-		int next = (context->backwards) ? a+1 : a-1;
+		int next = (context->backwards) ? a + 1 : a - 1;
 		int is_keyframed = FALSE;
 		MovieTrackingMarker *cur_marker = &track->markers[a];
 		MovieTrackingMarker *next_marker = NULL;
 
-		if (next>=0 && next<track->markersnr)
+		if (next >= 0 && next < track->markersnr)
 			next_marker = &track->markers[next];
 
 		/* if next mrker is disabled, stop searching keyframe and use current frame as keyframe */
@@ -1442,8 +1448,8 @@ int BKE_tracking_next(MovieTrackingContext *context)
 			margin[1] = MAX2(margin[1], (float)track->margin / ibuf_new->y);
 
 			/* do not track markers which are too close to boundary */
-			if (marker->pos[0]<margin[0] || marker->pos[0]>1.0f-margin[0] ||
-			    marker->pos[1]<margin[1] || marker->pos[1]>1.0f-margin[1])
+			if (marker->pos[0] < margin[0] || marker->pos[0] > 1.0f - margin[0] ||
+			    marker->pos[1] < margin[1] || marker->pos[1] > 1.0f - margin[1])
 			{
 				onbound = TRUE;
 			}
@@ -1669,7 +1675,8 @@ static int retrieve_libmv_reconstruct_tracks(MovieReconstructContext *context, M
 
 	reconstruction->camnr = 0;
 	reconstruction->cameras = NULL;
-	reconstructed = MEM_callocN((efra-sfra+1)*sizeof(MovieReconstructedCamera), "temp reconstructed camera");
+	reconstructed = MEM_callocN((efra - sfra + 1) * sizeof(MovieReconstructedCamera),
+	                            "temp reconstructed camera");
 
 	for (a = sfra; a <= efra; a++) {
 		double matd[4][4];
@@ -1704,8 +1711,9 @@ static int retrieve_libmv_reconstruct_tracks(MovieReconstructContext *context, M
 	}
 
 	if (reconstruction->camnr) {
-		reconstruction->cameras = MEM_callocN(reconstruction->camnr * sizeof(MovieReconstructedCamera), "reconstructed camera");
-		memcpy(reconstruction->cameras, reconstructed, reconstruction->camnr * sizeof(MovieReconstructedCamera));
+		int size = reconstruction->camnr * sizeof(MovieReconstructedCamera);
+		reconstruction->cameras = MEM_callocN(size, "reconstructed camera");
+		memcpy(reconstruction->cameras, reconstructed, size);
 	}
 
 	if (origin_set) {
@@ -1783,7 +1791,8 @@ int BKE_tracking_can_reconstruct(MovieTracking *tracking, MovieTrackingObject *o
 		return TRUE;
 	}
 	else if (count_tracks_on_both_keyframes(tracking, tracksbase) < 8) {
-		BLI_strncpy(error_msg, "At least 8 common tracks on both of keyframes are needed for reconstruction", error_size);
+		BLI_strncpy(error_msg, "At least 8 common tracks on both of keyframes are needed for reconstruction",
+		            error_size);
 
 		return FALSE;
 	}
@@ -1818,7 +1827,7 @@ MovieReconstructContext* BKE_tracking_reconstruction_context_new(MovieTracking *
 
 	track = tracksbase->first;
 	while (track) {
-		int first = 0, last = track->markersnr-1;
+		int first = 0, last = track->markersnr - 1;
 		MovieTrackingMarker *first_marker = &track->markers[0];
 		MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1];
 
@@ -1834,7 +1843,7 @@ MovieReconstructContext* BKE_tracking_reconstruction_context_new(MovieTracking *
 			last_marker--;
 		}
 
-		if (first<track->markersnr - 1)
+		if (first < track->markersnr - 1)
 			sfra = MIN2(sfra, first_marker->framenr);
 
 		if (last >= 0)
@@ -2010,21 +2019,21 @@ static int reconstruction_camera_index(MovieTrackingReconstruction *reconstructi
 	if (!reconstruction->camnr)
 		return -1;
 
-	if (framenr<cameras[0].framenr) {
+	if (framenr < cameras[0].framenr) {
 		if (nearest)
 			return 0;
 		else
 			return -1;
 	}
 
-	if (framenr>cameras[reconstruction->camnr - 1].framenr) {
+	if (framenr > cameras[reconstruction->camnr - 1].framenr) {
 		if (nearest)
 			return reconstruction->camnr - 1;
 		else
 			return -1;
 	}
 
-	if (reconstruction->last_camera<reconstruction->camnr)
+	if (reconstruction->last_camera < reconstruction->camnr)
 		a = reconstruction->last_camera;
 
 	if (cameras[a].framenr >= framenr)
@@ -2106,9 +2115,9 @@ void BKE_tracking_get_interpolated_camera(MovieTracking *tracking, MovieTracking
 	}
 
 	if (cameras[a].framenr != framenr && a > 0 && a < reconstruction->camnr - 1) {
-		float t = ((float)framenr-cameras[a].framenr) / (cameras[a + 1].framenr-cameras[a].framenr);
+		float t = ((float)framenr - cameras[a].framenr) / (cameras[a + 1].framenr - cameras[a].framenr);
 
-		blend_m4_m4m4(mat, cameras[a].mat, cameras[a+1].mat, t);
+		blend_m4_m4m4(mat, cameras[a].mat, cameras[a + 1].mat, t);
 	}
 	else {
 		copy_m4_m4(mat, cameras[a].mat);
@@ -2135,8 +2144,8 @@ void BKE_get_tracking_mat(Scene *scene, Object *ob, float mat[4][4])
 void BKE_tracking_camera_shift(MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty)
 {
 	/* indeed in both of cases it should be winx -- it's just how camera shift works for blender's camera */
-	*shiftx = (0.5f * winx-tracking->camera.principal[0]) / winx;
-	*shifty = (0.5f * winy-tracking->camera.principal[1]) / winx;
+	*shiftx = (0.5f * winx - tracking->camera.principal[0]) / winx;
+	*shifty = (0.5f * winy - tracking->camera.principal[1]) / winx;
 }
 
 void BKE_tracking_camera_to_blender(MovieTracking *tracking, Scene *scene, Camera *camera, int width, int height)
@@ -2145,9 +2154,9 @@ void BKE_tracking_camera_to_blender(MovieTracking *tracking, Scene *scene, Camer
 
 	camera->sensor_x = tracking->camera.sensor_width;
 	camera->sensor_fit = CAMERA_SENSOR_FIT_AUTO;
-	camera->lens = focal*camera->sensor_x/width;
+	camera->lens = focal * camera->sensor_x / width;
 
-	scene->r.xsch = width*tracking->camera.pixel_aspect;
+	scene->r.xsch = width * tracking->camera.pixel_aspect;
 	scene->r.ysch = height;
 
 	scene->r.xasp = 1.0f;
@@ -2160,7 +2169,7 @@ void BKE_tracking_projection_matrix(MovieTracking *tracking, MovieTrackingObject
                                     int framenr, int winx, int winy, float mat[4][4])
 {
 	MovieReconstructedCamera *camera;
-	float lens = tracking->camera.focal*tracking->camera.sensor_width/(float)winx;
+	float lens = tracking->camera.focal * tracking->camera.sensor_width / (float)winx;
 	float viewfac, pixsize, left, right, bottom, top, clipsta, clipend;
 	float winmat[4][4];
 	float ycor =  1.0f / tracking->camera.pixel_aspect;
@@ -2172,11 +2181,11 @@ void BKE_tracking_projection_matrix(MovieTracking *tracking, MovieTrackingObject
 	clipend = 1000.0f;
 
 	if (winx >= winy)
-		viewfac = (lens*winx)/tracking->camera.sensor_width;
+		viewfac = (lens * winx) / tracking->camera.sensor_width;
 	else
-		viewfac = (ycor*lens*winy)/tracking->camera.sensor_width;
+		viewfac = (ycor * lens * winy) / tracking->camera.sensor_width;
 
-	pixsize = clipsta/viewfac;
+	pixsize = clipsta / viewfac;
 
 	left = -0.5f * (float)winx + shiftx * winside;
 	bottom = -0.5f * (ycor) * (float)winy + shifty * winside;
@@ -2278,7 +2287,7 @@ void BKE_tracking_apply_intrinsics(MovieTracking *tracking, float co[2], float n
 
 #ifdef WITH_LIBMV
 	double x, y;
-	float aspy = 1.0f/tracking->camera.pixel_aspect;
+	float aspy = 1.0f / tracking->camera.pixel_aspect;
 
 	/* normalize coords */
 	x = (co[0] - camera->principal[0]) / camera->focal;
@@ -2326,7 +2335,7 @@ static int point_in_stroke(bGPDstroke *stroke, float x, float y)
 
 	prev = stroke->totpoints - 1;
 
-	for (i = 0; i<stroke->totpoints; i++) {
+	for (i = 0; i < stroke->totpoints; i++) {
 		if ((points[i].y < y && points[prev].y >= y) || (points[prev].y < y && points[i].y >= y)) {
 			float fac = (y - points[i].y) / (points[prev].y - points[i].y);
 
@@ -2507,7 +2516,7 @@ static void calculate_stabdata(MovieTracking *tracking, int framenr, float width
 		b[0] *= width;
 		b[1] *= height;
 
-		*angle = -atan2(a[0]*b[1]-a[1]*b[0], a[0]*b[0]+a[1]*b[1]);
+		*angle = -atan2(a[0] * b[1] - a[1] * b[0], a[0] * b[0] + a[1] * b[1]);
 		*angle *= stab->rotinf;
 
 		/* convert to rotation around image center */
@@ -2563,10 +2572,10 @@ static float stabilization_auto_scale_factor(MovieTracking *tracking, int width,
 
 			for (i = 0; i < 4; i++) {
 				int j;
-				float a[3] = {0.0f, 0.0f, 0.0f}, b[3]= {0.0f, 0.0f, 0.0f};
+				float a[3] = {0.0f, 0.0f, 0.0f}, b[3] = {0.0f, 0.0f, 0.0f};
 
 				copy_v3_v3(a, points[i]);
-				copy_v3_v3(b, points[(i+1)%4]);
+				copy_v3_v3(b, points[(i + 1) % 4]);
 
 				mul_m4_v3(mat, a);
 				mul_m4_v3(mat, b);
@@ -2622,7 +2631,7 @@ static float stabilization_auto_scale_factor(MovieTracking *tracking, int width,
 
 		stab->scale = scale;
 
-		if (stab->maxscale>0.0f)
+		if (stab->maxscale > 0.0f)
 			stab->scale = MIN2(stab->scale, stab->maxscale);
 	}
 	else {
@@ -2663,7 +2672,8 @@ static ImBuf* stabilize_alloc_ibuf(ImBuf *cacheibuf, ImBuf *srcibuf, int fill)
 	return cacheibuf;
 }
 
-void BKE_tracking_stabilization_data(MovieTracking *tracking, int framenr, int width, int height, float loc[2], float *scale, float *angle)
+void BKE_tracking_stabilization_data(MovieTracking *tracking, int framenr, int width, int height,
+                                     float loc[2], float *scale, float *angle)
 {
 	float firstmedian[2], median[2];
 	MovieTrackingStabilization *stab = &tracking->stabilization;
@@ -2701,7 +2711,8 @@ void BKE_tracking_stabilization_data(MovieTracking *tracking, int framenr, int w
 	}
 }
 
-ImBuf *BKE_tracking_stabilize(MovieTracking *tracking, int framenr, ImBuf *ibuf, float loc[2], float *scale, float *angle)
+ImBuf *BKE_tracking_stabilize(MovieTracking *tracking, int framenr, ImBuf *ibuf,
+                              float loc[2], float *scale, float *angle)
 {
 	float tloc[2], tscale, tangle;
 	MovieTrackingStabilization *stab = &tracking->stabilization;
@@ -2798,10 +2809,11 @@ ImBuf *BKE_tracking_stabilize(MovieTracking *tracking, int framenr, ImBuf *ibuf,
 	return tmpibuf;
 }
 
-void BKE_tracking_stabdata_to_mat4(int width, int height, float aspect, float loc[2], float scale, float angle, float mat[4][4])
+void BKE_tracking_stabdata_to_mat4(int width, int height, float aspect,
+                                   float loc[2], float scale, float angle, float mat[4][4])
 {
 	float lmat[4][4], rmat[4][4], smat[4][4], cmat[4][4], icmat[4][4], amat[4][4], iamat[4][4];
-	float svec[3]= {scale, scale, scale};
+	float svec[3] = {scale, scale, scale};
 
 	unit_m4(rmat);
 	unit_m4(lmat);
@@ -3013,7 +3025,7 @@ void BKE_tracking_remove_object(MovieTracking *tracking, MovieTrackingObject *ob
 	MovieTrackingTrack *track;
 	int index = BLI_findindex(&tracking->objects, object);
 
-	if (index<0)
+	if (index < 0)
 		return;
 
 	if (object->flag & TRACKING_OBJECT_CAMERA) {
@@ -3034,7 +3046,7 @@ void BKE_tracking_remove_object(MovieTracking *tracking, MovieTrackingObject *ob
 
 	tracking->tot_object--;
 
-	if (index>0)
+	if (index > 0)
 		tracking->objectnr = index - 1;
 	else
 		tracking->objectnr = 0;
@@ -3042,7 +3054,8 @@ void BKE_tracking_remove_object(MovieTracking *tracking, MovieTrackingObject *ob
 
 void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *object)
 {
-	BLI_uniquename(&tracking->objects, object, "Object", '.', offsetof(MovieTrackingObject, name), sizeof(object->name));
+	BLI_uniquename(&tracking->objects, object, "Object", '.',
+	               offsetof(MovieTrackingObject, name), sizeof(object->name));
 }
 
 MovieTrackingObject *BKE_tracking_named_object(MovieTracking *tracking, const char *name)