ClangFormat: apply to source, most of intern

Apply clang format as proposed in T53211.

For details on usage and instructions for migrating branches
without conflicts, see:

https://wiki.blender.org/wiki/Tools/ClangFormat

1 files changed, 407 insertions, 385 deletions

diff --git a/source/blender/blenkernel/intern/tracking_solver.c b/source/blender/blenkernel/intern/tracking_solver.c
index 51bd4c3c871..c3759fd01bb 100644
--- a/source/blender/blenkernel/intern/tracking_solver.c
+++ b/source/blender/blenkernel/intern/tracking_solver.c
@@ -47,293 +47,303 @@
 #include "tracking_private.h"
 
 typedef struct MovieReconstructContext {
-	struct libmv_Tracks *tracks;
-	bool select_keyframes;
-	int keyframe1, keyframe2;
-	int refine_flags;
+  struct libmv_Tracks *tracks;
+  bool select_keyframes;
+  int keyframe1, keyframe2;
+  int refine_flags;
 
-	struct libmv_Reconstruction *reconstruction;
+  struct libmv_Reconstruction *reconstruction;
 
-	char object_name[MAX_NAME];
-	bool is_camera;
-	short motion_flag;
+  char object_name[MAX_NAME];
+  bool is_camera;
+  short motion_flag;
 
-	libmv_CameraIntrinsicsOptions camera_intrinsics_options;
+  libmv_CameraIntrinsicsOptions camera_intrinsics_options;
 
-	float reprojection_error;
+  float reprojection_error;
 
-	TracksMap *tracks_map;
+  TracksMap *tracks_map;
 
-	int sfra, efra;
+  int sfra, efra;
 } MovieReconstructContext;
 
 typedef struct ReconstructProgressData {
-	short *stop;
-	short *do_update;
-	float *progress;
-	char *stats_message;
-	int message_size;
+  short *stop;
+  short *do_update;
+  float *progress;
+  char *stats_message;
+  int message_size;
 } ReconstructProgressData;
 
 /* Create new libmv Tracks structure from blender's tracks list. */
-static struct libmv_Tracks *libmv_tracks_new(MovieClip *clip, ListBase *tracksbase, int width, int height)
+static struct libmv_Tracks *libmv_tracks_new(MovieClip *clip,
+                                             ListBase *tracksbase,
+                                             int width,
+                                             int height)
 {
-	int tracknr = 0;
-	MovieTrackingTrack *track;
-	struct libmv_Tracks *tracks = libmv_tracksNew();
-
-	track = tracksbase->first;
-	while (track) {
-		FCurve *weight_fcurve;
-		int a = 0;
-
-		weight_fcurve = id_data_find_fcurve(&clip->id, track, &RNA_MovieTrackingTrack,
-		                                    "weight", 0, NULL);
-
-		for (a = 0; a < track->markersnr; a++) {
-			MovieTrackingMarker *marker = &track->markers[a];
-
-			if ((marker->flag & MARKER_DISABLED) == 0) {
-				float weight = track->weight;
-
-				if (weight_fcurve) {
-					int scene_framenr =
-						BKE_movieclip_remap_clip_to_scene_frame(clip, marker->framenr);
-					weight = evaluate_fcurve(weight_fcurve, scene_framenr);
-				}
-
-				libmv_tracksInsert(tracks, marker->framenr, tracknr,
-				                   (marker->pos[0] + track->offset[0]) * width,
-				                   (marker->pos[1] + track->offset[1]) * height,
-				                   weight);
-			}
-		}
-
-		track = track->next;
-		tracknr++;
-	}
-
-	return tracks;
+  int tracknr = 0;
+  MovieTrackingTrack *track;
+  struct libmv_Tracks *tracks = libmv_tracksNew();
+
+  track = tracksbase->first;
+  while (track) {
+    FCurve *weight_fcurve;
+    int a = 0;
+
+    weight_fcurve = id_data_find_fcurve(
+        &clip->id, track, &RNA_MovieTrackingTrack, "weight", 0, NULL);
+
+    for (a = 0; a < track->markersnr; a++) {
+      MovieTrackingMarker *marker = &track->markers[a];
+
+      if ((marker->flag & MARKER_DISABLED) == 0) {
+        float weight = track->weight;
+
+        if (weight_fcurve) {
+          int scene_framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, marker->framenr);
+          weight = evaluate_fcurve(weight_fcurve, scene_framenr);
+        }
+
+        libmv_tracksInsert(tracks,
+                           marker->framenr,
+                           tracknr,
+                           (marker->pos[0] + track->offset[0]) * width,
+                           (marker->pos[1] + track->offset[1]) * height,
+                           weight);
+      }
+    }
+
+    track = track->next;
+    tracknr++;
+  }
+
+  return tracks;
 }
 
 /* Retrieve refined camera intrinsics from libmv to blender. */
-static void reconstruct_retrieve_libmv_intrinsics(MovieReconstructContext *context, MovieTracking *tracking)
+static void reconstruct_retrieve_libmv_intrinsics(MovieReconstructContext *context,
+                                                  MovieTracking *tracking)
 {
-	struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
-	struct libmv_CameraIntrinsics *libmv_intrinsics = libmv_reconstructionExtractIntrinsics(libmv_reconstruction);
+  struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
+  struct libmv_CameraIntrinsics *libmv_intrinsics = libmv_reconstructionExtractIntrinsics(
+      libmv_reconstruction);
 
-	libmv_CameraIntrinsicsOptions camera_intrinsics_options;
-	libmv_cameraIntrinsicsExtractOptions(libmv_intrinsics, &camera_intrinsics_options);
+  libmv_CameraIntrinsicsOptions camera_intrinsics_options;
+  libmv_cameraIntrinsicsExtractOptions(libmv_intrinsics, &camera_intrinsics_options);
 
-	tracking_trackingCameraFromIntrinscisOptions(tracking,
-	                                             &camera_intrinsics_options);
+  tracking_trackingCameraFromIntrinscisOptions(tracking, &camera_intrinsics_options);
 }
 
 /* Retrieve reconstructed tracks from libmv to blender.
  * Actually, this also copies reconstructed cameras
  * from libmv to movie clip datablock.
  */
-static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, MovieTracking *tracking)
+static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context,
+                                              MovieTracking *tracking)
 {
-	struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
-	MovieTrackingReconstruction *reconstruction = NULL;
-	MovieReconstructedCamera *reconstructed;
-	MovieTrackingTrack *track;
-	ListBase *tracksbase =  NULL;
-	int tracknr = 0, a;
-	bool ok = true;
-	bool origin_set = false;
-	int sfra = context->sfra, efra = context->efra;
-	float imat[4][4];
-
-	if (context->is_camera) {
-		tracksbase = &tracking->tracks;
-		reconstruction = &tracking->reconstruction;
-	}
-	else {
-		MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
-
-		tracksbase = &object->tracks;
-		reconstruction = &object->reconstruction;
-	}
-
-	unit_m4(imat);
-
-	track = tracksbase->first;
-	while (track) {
-		double pos[3];
-
-		if (libmv_reprojectionPointForTrack(libmv_reconstruction, tracknr, pos)) {
-			track->bundle_pos[0] = pos[0];
-			track->bundle_pos[1] = pos[1];
-			track->bundle_pos[2] = pos[2];
-
-			track->flag |= TRACK_HAS_BUNDLE;
-			track->error = libmv_reprojectionErrorForTrack(libmv_reconstruction, tracknr);
-		}
-		else {
-			track->flag &= ~TRACK_HAS_BUNDLE;
-			ok = false;
-
-			printf("Unable to reconstruct position for track #%d '%s'\n", tracknr, track->name);
-		}
-
-		track = track->next;
-		tracknr++;
-	}
-
-	if (reconstruction->cameras)
-		MEM_freeN(reconstruction->cameras);
-
-	reconstruction->camnr = 0;
-	reconstruction->cameras = NULL;
-	reconstructed = MEM_callocN((efra - sfra + 1) * sizeof(MovieReconstructedCamera),
-	                            "temp reconstructed camera");
-
-	for (a = sfra; a <= efra; a++) {
-		double matd[4][4];
-
-		if (libmv_reprojectionCameraForImage(libmv_reconstruction, a, matd)) {
-			int i, j;
-			float mat[4][4];
-			float error = libmv_reprojectionErrorForImage(libmv_reconstruction, a);
-
-			for (i = 0; i < 4; i++) {
-				for (j = 0; j < 4; j++)
-					mat[i][j] = matd[i][j];
-			}
-
-			/* Ensure first camera has got zero rotation and transform.
-			 * This is essential for object tracking to work -- this way
-			 * we'll always know object and environment are properly
-			 * oriented.
-			 *
-			 * There's one weak part tho, which is requirement object
-			 * motion starts at the same frame as camera motion does,
-			 * otherwise that;' be a russian roulette whether object is
-			 * aligned correct or not.
-			 */
-			if (!origin_set) {
-				invert_m4_m4(imat, mat);
-				unit_m4(mat);
-				origin_set = true;
-			}
-			else {
-				mul_m4_m4m4(mat, imat, mat);
-			}
-
-			copy_m4_m4(reconstructed[reconstruction->camnr].mat, mat);
-			reconstructed[reconstruction->camnr].framenr = a;
-			reconstructed[reconstruction->camnr].error = error;
-			reconstruction->camnr++;
-		}
-		else {
-			ok = false;
-			printf("No camera for frame %d\n", a);
-		}
-	}
-
-	if (reconstruction->camnr) {
-		int size = reconstruction->camnr * sizeof(MovieReconstructedCamera);
-		reconstruction->cameras = MEM_callocN(size, "reconstructed camera");
-		memcpy(reconstruction->cameras, reconstructed, size);
-	}
-
-	if (origin_set) {
-		track = tracksbase->first;
-		while (track) {
-			if (track->flag & TRACK_HAS_BUNDLE)
-				mul_v3_m4v3(track->bundle_pos, imat, track->bundle_pos);
-
-			track = track->next;
-		}
-	}
-
-	MEM_freeN(reconstructed);
-
-	return ok;
+  struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
+  MovieTrackingReconstruction *reconstruction = NULL;
+  MovieReconstructedCamera *reconstructed;
+  MovieTrackingTrack *track;
+  ListBase *tracksbase = NULL;
+  int tracknr = 0, a;
+  bool ok = true;
+  bool origin_set = false;
+  int sfra = context->sfra, efra = context->efra;
+  float imat[4][4];
+
+  if (context->is_camera) {
+    tracksbase = &tracking->tracks;
+    reconstruction = &tracking->reconstruction;
+  }
+  else {
+    MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
+
+    tracksbase = &object->tracks;
+    reconstruction = &object->reconstruction;
+  }
+
+  unit_m4(imat);
+
+  track = tracksbase->first;
+  while (track) {
+    double pos[3];
+
+    if (libmv_reprojectionPointForTrack(libmv_reconstruction, tracknr, pos)) {
+      track->bundle_pos[0] = pos[0];
+      track->bundle_pos[1] = pos[1];
+      track->bundle_pos[2] = pos[2];
+
+      track->flag |= TRACK_HAS_BUNDLE;
+      track->error = libmv_reprojectionErrorForTrack(libmv_reconstruction, tracknr);
+    }
+    else {
+      track->flag &= ~TRACK_HAS_BUNDLE;
+      ok = false;
+
+      printf("Unable to reconstruct position for track #%d '%s'\n", tracknr, track->name);
+    }
+
+    track = track->next;
+    tracknr++;
+  }
+
+  if (reconstruction->cameras)
+    MEM_freeN(reconstruction->cameras);
+
+  reconstruction->camnr = 0;
+  reconstruction->cameras = NULL;
+  reconstructed = MEM_callocN((efra - sfra + 1) * sizeof(MovieReconstructedCamera),
+                              "temp reconstructed camera");
+
+  for (a = sfra; a <= efra; a++) {
+    double matd[4][4];
+
+    if (libmv_reprojectionCameraForImage(libmv_reconstruction, a, matd)) {
+      int i, j;
+      float mat[4][4];
+      float error = libmv_reprojectionErrorForImage(libmv_reconstruction, a);
+
+      for (i = 0; i < 4; i++) {
+        for (j = 0; j < 4; j++)
+          mat[i][j] = matd[i][j];
+      }
+
+      /* Ensure first camera has got zero rotation and transform.
+       * This is essential for object tracking to work -- this way
+       * we'll always know object and environment are properly
+       * oriented.
+       *
+       * There's one weak part tho, which is requirement object
+       * motion starts at the same frame as camera motion does,
+       * otherwise that;' be a russian roulette whether object is
+       * aligned correct or not.
+       */
+      if (!origin_set) {
+        invert_m4_m4(imat, mat);
+        unit_m4(mat);
+        origin_set = true;
+      }
+      else {
+        mul_m4_m4m4(mat, imat, mat);
+      }
+
+      copy_m4_m4(reconstructed[reconstruction->camnr].mat, mat);
+      reconstructed[reconstruction->camnr].framenr = a;
+      reconstructed[reconstruction->camnr].error = error;
+      reconstruction->camnr++;
+    }
+    else {
+      ok = false;
+      printf("No camera for frame %d\n", a);
+    }
+  }
+
+  if (reconstruction->camnr) {
+    int size = reconstruction->camnr * sizeof(MovieReconstructedCamera);
+    reconstruction->cameras = MEM_callocN(size, "reconstructed camera");
+    memcpy(reconstruction->cameras, reconstructed, size);
+  }
+
+  if (origin_set) {
+    track = tracksbase->first;
+    while (track) {
+      if (track->flag & TRACK_HAS_BUNDLE)
+        mul_v3_m4v3(track->bundle_pos, imat, track->bundle_pos);
+
+      track = track->next;
+    }
+  }
+
+  MEM_freeN(reconstructed);
+
+  return ok;
 }
 
 /* Retrieve all the libmv data from context to blender's side data blocks. */
 static int reconstruct_retrieve_libmv(MovieReconstructContext *context, MovieTracking *tracking)
 {
-	/* take the intrinsics back from libmv */
-	reconstruct_retrieve_libmv_intrinsics(context, tracking);
+  /* take the intrinsics back from libmv */
+  reconstruct_retrieve_libmv_intrinsics(context, tracking);
 
-	return reconstruct_retrieve_libmv_tracks(context, tracking);
+  return reconstruct_retrieve_libmv_tracks(context, tracking);
 }
 
 /* Convert blender's refinement flags to libmv's. */
-static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking, MovieTrackingObject *object)
+static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking,
+                                                   MovieTrackingObject *object)
 {
-	int refine = tracking->settings.refine_camera_intrinsics;
-	int flags = 0;
+  int refine = tracking->settings.refine_camera_intrinsics;
+  int flags = 0;
 
-	if ((object->flag & TRACKING_OBJECT_CAMERA) == 0)
-		return 0;
+  if ((object->flag & TRACKING_OBJECT_CAMERA) == 0)
+    return 0;
 
-	if (refine & REFINE_FOCAL_LENGTH)
-		flags |= LIBMV_REFINE_FOCAL_LENGTH;
+  if (refine & REFINE_FOCAL_LENGTH)
+    flags |= LIBMV_REFINE_FOCAL_LENGTH;
 
-	if (refine & REFINE_PRINCIPAL_POINT)
-		flags |= LIBMV_REFINE_PRINCIPAL_POINT;
+  if (refine & REFINE_PRINCIPAL_POINT)
+    flags |= LIBMV_REFINE_PRINCIPAL_POINT;
 
-	if (refine & REFINE_RADIAL_DISTORTION_K1)
-		flags |= LIBMV_REFINE_RADIAL_DISTORTION_K1;
+  if (refine & REFINE_RADIAL_DISTORTION_K1)
+    flags |= LIBMV_REFINE_RADIAL_DISTORTION_K1;
 
-	if (refine & REFINE_RADIAL_DISTORTION_K2)
-		flags |= LIBMV_REFINE_RADIAL_DISTORTION_K2;
+  if (refine & REFINE_RADIAL_DISTORTION_K2)
+    flags |= LIBMV_REFINE_RADIAL_DISTORTION_K2;
 
-	return flags;
+  return flags;
 }
 
 /* Count tracks which has markers at both of keyframes. */
-static int reconstruct_count_tracks_on_both_keyframes(MovieTracking *tracking, MovieTrackingObject *object)
+static int reconstruct_count_tracks_on_both_keyframes(MovieTracking *tracking,
+                                                      MovieTrackingObject *object)
 {
-	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
-	int tot = 0;
-	int frame1 = object->keyframe1, frame2 = object->keyframe2;
-	MovieTrackingTrack *track;
-
-	track = tracksbase->first;
-	while (track) {
-		if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame1)) {
-			if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame2)) {
-				tot++;
-			}
-		}
-
-		track = track->next;
-	}
-
-	return tot;
+  ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
+  int tot = 0;
+  int frame1 = object->keyframe1, frame2 = object->keyframe2;
+  MovieTrackingTrack *track;
+
+  track = tracksbase->first;
+  while (track) {
+    if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame1)) {
+      if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame2)) {
+        tot++;
+      }
+    }
+
+    track = track->next;
+  }
+
+  return tot;
 }
 
 /* Perform early check on whether everything is fine to start reconstruction. */
-bool BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObject *object,
-                                       char *error_msg, int error_size)
+bool BKE_tracking_reconstruction_check(MovieTracking *tracking,
+                                       MovieTrackingObject *object,
+                                       char *error_msg,
+                                       int error_size)
 {
-	if (tracking->settings.motion_flag & TRACKING_MOTION_MODAL) {
-		/* TODO: check for number of tracks? */
-		return true;
-	}
-	else if ((tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) == 0) {
-		/* automatic keyframe selection does not require any pre-process checks */
-		if (reconstruct_count_tracks_on_both_keyframes(tracking, object) < 8) {
-			BLI_strncpy(error_msg,
-			            N_("At least 8 common tracks on both keyframes are needed for reconstruction"),
-			            error_size);
-
-			return false;
-		}
-	}
+  if (tracking->settings.motion_flag & TRACKING_MOTION_MODAL) {
+    /* TODO: check for number of tracks? */
+    return true;
+  }
+  else if ((tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) == 0) {
+    /* automatic keyframe selection does not require any pre-process checks */
+    if (reconstruct_count_tracks_on_both_keyframes(tracking, object) < 8) {
+      BLI_strncpy(error_msg,
+                  N_("At least 8 common tracks on both keyframes are needed for reconstruction"),
+                  error_size);
+
+      return false;
+    }
+  }
 
 #ifndef WITH_LIBMV
-	BLI_strncpy(error_msg, N_("Blender is compiled without motion tracking library"), error_size);
-	return false;
+  BLI_strncpy(error_msg, N_("Blender is compiled without motion tracking library"), error_size);
+  return false;
 #endif
 
-	return true;
+  return true;
 }
 
 /* Create context for camera/object motion reconstruction.
@@ -341,106 +351,111 @@ bool BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObj
  * clip datablock, so editing this clip is safe during
  * reconstruction job is in progress.
  */
-MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip, MovieTrackingObject *object,
-                                                                 int keyframe1, int keyframe2, int width, int height)
+MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip,
+                                                                 MovieTrackingObject *object,
+                                                                 int keyframe1,
+                                                                 int keyframe2,
+                                                                 int width,
+                                                                 int height)
 {
-	MovieTracking *tracking = &clip->tracking;
-	MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext), "MovieReconstructContext data");
-	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
-	float aspy = 1.0f / tracking->camera.pixel_aspect;
-	int num_tracks = BLI_listbase_count(tracksbase);
-	int sfra = INT_MAX, efra = INT_MIN;
-	MovieTrackingTrack *track;
+  MovieTracking *tracking = &clip->tracking;
+  MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext),
+                                                 "MovieReconstructContext data");
+  ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
+  float aspy = 1.0f / tracking->camera.pixel_aspect;
+  int num_tracks = BLI_listbase_count(tracksbase);
+  int sfra = INT_MAX, efra = INT_MIN;
+  MovieTrackingTrack *track;
 
-	BLI_strncpy(context->object_name, object->name, sizeof(context->object_name));
-	context->is_camera = object->flag & TRACKING_OBJECT_CAMERA;
-	context->motion_flag = tracking->settings.motion_flag;
+  BLI_strncpy(context->object_name, object->name, sizeof(context->object_name));
+  context->is_camera = object->flag & TRACKING_OBJECT_CAMERA;
+  context->motion_flag = tracking->settings.motion_flag;
 
-	context->select_keyframes =
-		(tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) != 0;
+  context->select_keyframes = (tracking->settings.reconstruction_flag &
+                               TRACKING_USE_KEYFRAME_SELECTION) != 0;
 
-	tracking_cameraIntrinscisOptionsFromTracking(tracking,
-	                                             width, height,
-	                                             &context->camera_intrinsics_options);
+  tracking_cameraIntrinscisOptionsFromTracking(
+      tracking, width, height, &context->camera_intrinsics_options);
 
-	context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
+  context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
 
-	track = tracksbase->first;
-	while (track) {
-		int first = 0, last = track->markersnr - 1;
-		MovieTrackingMarker *first_marker = &track->markers[0];
-		MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1];
+  track = tracksbase->first;
+  while (track) {
+    int first = 0, last = track->markersnr - 1;
+    MovieTrackingMarker *first_marker = &track->markers[0];
+    MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1];
 
-		/* find first not-disabled marker */
-		while (first <= track->markersnr - 1 && first_marker->flag & MARKER_DISABLED) {
-			first++;
-			first_marker++;
-		}
+    /* find first not-disabled marker */
+    while (first <= track->markersnr - 1 && first_marker->flag & MARKER_DISABLED) {
+      first++;
+      first_marker++;
+    }
 
-		/* find last not-disabled marker */
-		while (last >= 0 && last_marker->flag & MARKER_DISABLED) {
-			last--;
-			last_marker--;
-		}
+    /* find last not-disabled marker */
+    while (last >= 0 && last_marker->flag & MARKER_DISABLED) {
+      last--;
+      last_marker--;
+    }
 
-		if (first <= track->markersnr - 1)
-			sfra = min_ii(sfra, first_marker->framenr);
+    if (first <= track->markersnr - 1)
+      sfra = min_ii(sfra, first_marker->framenr);
 
-		if (last >= 0)
-			efra = max_ii(efra, last_marker->framenr);
+    if (last >= 0)
+      efra = max_ii(efra, last_marker->framenr);
 
-		tracks_map_insert(context->tracks_map, track, NULL);
+    tracks_map_insert(context->tracks_map, track, NULL);
 
-		track = track->next;
-	}
+    track = track->next;
+  }
 
-	context->sfra = sfra;
-	context->efra = efra;
+  context->sfra = sfra;
+  context->efra = efra;
 
-	context->tracks = libmv_tracks_new(clip, tracksbase, width, height * aspy);
-	context->keyframe1 = keyframe1;
-	context->keyframe2 = keyframe2;
-	context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, object);
+  context->tracks = libmv_tracks_new(clip, tracksbase, width, height * aspy);
+  context->keyframe1 = keyframe1;
+  context->keyframe2 = keyframe2;
+  context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, object);
 
-	return context;
+  return context;
 }
 
 /* Free memory used by a reconstruction process. */
 void BKE_tracking_reconstruction_context_free(MovieReconstructContext *context)
 {
-	if (context->reconstruction)
-		libmv_reconstructionDestroy(context->reconstruction);
+  if (context->reconstruction)
+    libmv_reconstructionDestroy(context->reconstruction);
 
-	libmv_tracksDestroy(context->tracks);
+  libmv_tracksDestroy(context->tracks);
 
-	tracks_map_free(context->tracks_map, NULL);
+  tracks_map_free(context->tracks_map, NULL);
 
-	MEM_freeN(context);
+  MEM_freeN(context);
 }
 
 /* Callback which is called from libmv side to update progress in the interface. */
 static void reconstruct_update_solve_cb(void *customdata, double progress, const char *message)
 {
-	ReconstructProgressData *progressdata = customdata;
+  ReconstructProgressData *progressdata = customdata;
 
-	if (progressdata->progress) {
-		*progressdata->progress = progress;
-		*progressdata->do_update = true;
-	}
+  if (progressdata->progress) {
+    *progressdata->progress = progress;
+    *progressdata->do_update = true;
+  }
 
-	BLI_snprintf(progressdata->stats_message, progressdata->message_size, "Solving camera | %s", message);
+  BLI_snprintf(
+      progressdata->stats_message, progressdata->message_size, "Solving camera | %s", message);
 }
 
 /* Fill in reconstruction options structure from reconstruction context. */
 static void reconstructionOptionsFromContext(libmv_ReconstructionOptions *reconstruction_options,
                                              MovieReconstructContext *context)
 {
-	reconstruction_options->select_keyframes = context->select_keyframes;
+  reconstruction_options->select_keyframes = context->select_keyframes;
 
-	reconstruction_options->keyframe1 = context->keyframe1;
-	reconstruction_options->keyframe2 = context->keyframe2;
+  reconstruction_options->keyframe1 = context->keyframe1;
+  reconstruction_options->keyframe2 = context->keyframe2;
 
-	reconstruction_options->refine_intrinsics = context->refine_flags;
+  reconstruction_options->refine_intrinsics = context->refine_flags;
 }
 
 /* Solve camera/object motion and reconstruct 3D markers position
@@ -452,45 +467,51 @@ static void reconstructionOptionsFromContext(libmv_ReconstructionOptions *recons
  * do_update, progress and stat_message are set by reconstruction
  * callback in libmv side and passing to an interface.
  */
-void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *stop, short *do_update,
-                                       float *progress, char *stats_message, int message_size)
+void BKE_tracking_reconstruction_solve(MovieReconstructContext *context,
+                                       short *stop,
+                                       short *do_update,
+                                       float *progress,
+                                       char *stats_message,
+                                       int message_size)
 {
-	float error;
-
-	ReconstructProgressData progressdata;
-
-	libmv_ReconstructionOptions reconstruction_options;
-
-	progressdata.stop = stop;
-	progressdata.do_update = do_update;
-	progressdata.progress = progress;
-	progressdata.stats_message = stats_message;
-	progressdata.message_size = message_size;
-
-	reconstructionOptionsFromContext(&reconstruction_options, context);
-
-	if (context->motion_flag & TRACKING_MOTION_MODAL) {
-		context->reconstruction = libmv_solveModal(context->tracks,
-		                                           &context->camera_intrinsics_options,
-		                                           &reconstruction_options,
-		                                           reconstruct_update_solve_cb, &progressdata);
-	}
-	else {
-		context->reconstruction = libmv_solveReconstruction(context->tracks,
-		                                                    &context->camera_intrinsics_options,
-		                                                    &reconstruction_options,
-		                                                    reconstruct_update_solve_cb, &progressdata);
-
-		if (context->select_keyframes) {
-			/* store actual keyframes used for reconstruction to update them in the interface later */
-			context->keyframe1 = reconstruction_options.keyframe1;
-			context->keyframe2 = reconstruction_options.keyframe2;
-		}
-	}
-
-	error = libmv_reprojectionError(context->reconstruction);
-
-	context->reprojection_error = error;
+  float error;
+
+  ReconstructProgressData progressdata;
+
+  libmv_ReconstructionOptions reconstruction_options;
+
+  progressdata.stop = stop;
+  progressdata.do_update = do_update;
+  progressdata.progress = progress;
+  progressdata.stats_message = stats_message;
+  progressdata.message_size = message_size;
+
+  reconstructionOptionsFromContext(&reconstruction_options, context);
+
+  if (context->motion_flag & TRACKING_MOTION_MODAL) {
+    context->reconstruction = libmv_solveModal(context->tracks,
+                                               &context->camera_intrinsics_options,
+                                               &reconstruction_options,
+                                               reconstruct_update_solve_cb,
+                                               &progressdata);
+  }
+  else {
+    context->reconstruction = libmv_solveReconstruction(context->tracks,
+                                                        &context->camera_intrinsics_options,
+                                                        &reconstruction_options,
+                                                        reconstruct_update_solve_cb,
+                                                        &progressdata);
+
+    if (context->select_keyframes) {
+      /* store actual keyframes used for reconstruction to update them in the interface later */
+      context->keyframe1 = reconstruction_options.keyframe1;
+      context->keyframe2 = reconstruction_options.keyframe2;
+    }
+  }
+
+  error = libmv_reprojectionError(context->reconstruction);
+
+  context->reprojection_error = error;
 }
 
 /* Finish reconstruction process by copying reconstructed data
@@ -498,62 +519,63 @@ void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *
  */
 bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTracking *tracking)
 {
-	MovieTrackingReconstruction *reconstruction;
-	MovieTrackingObject *object;
+  MovieTrackingReconstruction *reconstruction;
+  MovieTrackingObject *object;
 
-	if (!libmv_reconstructionIsValid(context->reconstruction)) {
-		printf("Failed solve the motion: most likely there are no good keyframes\n");
-		return false;
-	}
+  if (!libmv_reconstructionIsValid(context->reconstruction)) {
+    printf("Failed solve the motion: most likely there are no good keyframes\n");
+    return false;
+  }
 
-	tracks_map_merge(context->tracks_map, tracking);
-	BKE_tracking_dopesheet_tag_update(tracking);
+  tracks_map_merge(context->tracks_map, tracking);
+  BKE_tracking_dopesheet_tag_update(tracking);
 
-	object = BKE_tracking_object_get_named(tracking, context->object_name);
+  object = BKE_tracking_object_get_named(tracking, context->object_name);
 
-	if (context->is_camera)
-		reconstruction = &tracking->reconstruction;
-	else
-		reconstruction = &object->reconstruction;
+  if (context->is_camera)
+    reconstruction = &tracking->reconstruction;
+  else
+    reconstruction = &object->reconstruction;
 
-	/* update keyframe in the interface */
-	if (context->select_keyframes) {
-		object->keyframe1 = context->keyframe1;
-		object->keyframe2 = context->keyframe2;
-	}
+  /* update keyframe in the interface */
+  if (context->select_keyframes) {
+    object->keyframe1 = context->keyframe1;
+    object->keyframe2 = context->keyframe2;
+  }
 
-	reconstruction->error = context->reprojection_error;
-	reconstruction->flag |= TRACKING_RECONSTRUCTED;
+  reconstruction->error = context->reprojection_error;
+  reconstruction->flag |= TRACKING_RECONSTRUCTED;
 
-	if (!reconstruct_retrieve_libmv(context, tracking))
-		return false;
+  if (!reconstruct_retrieve_libmv(context, tracking))
+    return false;
 
-	return true;
+  return true;
 }
 
-static void tracking_scale_reconstruction(ListBase *tracksbase, MovieTrackingReconstruction *reconstruction,
+static void tracking_scale_reconstruction(ListBase *tracksbase,
+                                          MovieTrackingReconstruction *reconstruction,
                                           const float scale[3])
 {
-	MovieTrackingTrack *track;
-	int i;
-	float first_camera_delta[3] = {0.0f, 0.0f, 0.0f};
-
-	if (reconstruction->camnr > 0) {
-		mul_v3_v3v3(first_camera_delta, reconstruction->cameras[0].mat[3], scale);
-	}
-
-	for (i = 0; i < reconstruction->camnr; i++) {
-		MovieReconstructedCamera *camera = &reconstruction->cameras[i];
-		mul_v3_v3(camera->mat[3], scale);
-		sub_v3_v3(camera->mat[3], first_camera_delta);
-	}
-
-	for (track = tracksbase->first; track; track = track->next) {
-		if (track->flag & TRACK_HAS_BUNDLE) {
-			mul_v3_v3(track->bundle_pos, scale);
-			sub_v3_v3(track->bundle_pos, first_camera_delta);
-		}
-	}
+  MovieTrackingTrack *track;
+  int i;
+  float first_camera_delta[3] = {0.0f, 0.0f, 0.0f};
+
+  if (reconstruction->camnr > 0) {
+    mul_v3_v3v3(first_camera_delta, reconstruction->cameras[0].mat[3], scale);
+  }
+
+  for (i = 0; i < reconstruction->camnr; i++) {
+    MovieReconstructedCamera *camera = &reconstruction->cameras[i];
+    mul_v3_v3(camera->mat[3], scale);
+    sub_v3_v3(camera->mat[3], first_camera_delta);
+  }
+
+  for (track = tracksbase->first; track; track = track->next) {
+    if (track->flag & TRACK_HAS_BUNDLE) {
+      mul_v3_v3(track->bundle_pos, scale);
+      sub_v3_v3(track->bundle_pos, first_camera_delta);
+    }
+  }
 }
 
 /* Apply scale on all reconstructed cameras and bundles,
@@ -561,15 +583,15 @@ static void tracking_scale_reconstruction(ListBase *tracksbase, MovieTrackingRec
  */
 void BKE_tracking_reconstruction_scale(MovieTracking *tracking, float scale[3])
 {
-	MovieTrackingObject *object;
+  MovieTrackingObject *object;
 
-	for (object = tracking->objects.first; object; object = object->next) {
-		ListBase *tracksbase;
-		MovieTrackingReconstruction *reconstruction;
+  for (object = tracking->objects.first; object; object = object->next) {
+    ListBase *tracksbase;
+    MovieTrackingReconstruction *reconstruction;
 
-		tracksbase = BKE_tracking_object_get_tracks(tracking, object);
-		reconstruction = BKE_tracking_object_get_reconstruction(tracking, object);
+    tracksbase = BKE_tracking_object_get_tracks(tracking, object);
+    reconstruction = BKE_tracking_object_get_reconstruction(tracking, object);
 
-		tracking_scale_reconstruction(tracksbase, reconstruction, scale);
-	}
+    tracking_scale_reconstruction(tracksbase, reconstruction, scale);
+  }
 }