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, 400 insertions, 489 deletions

diff --git a/source/blender/blenkernel/intern/tracking_auto.c b/source/blender/blenkernel/intern/tracking_auto.c
index bddb5315781..e93a5780b81 100644
--- a/source/blender/blenkernel/intern/tracking_auto.c
+++ b/source/blender/blenkernel/intern/tracking_auto.c
@@ -27,7 +27,7 @@
 #include "MEM_guardedalloc.h"
 
 #include "DNA_movieclip_types.h"
-#include "DNA_object_types.h"   /* SELECT */
+#include "DNA_object_types.h" /* SELECT */
 
 #include "BLI_utildefines.h"
 #include "BLI_listbase.h"
@@ -42,54 +42,54 @@
 #include "tracking_private.h"
 
 typedef struct AutoTrackOptions {
-	int clip_index;  /** Index of the clip this track belogs to. */
-	int track_index;  /* Index of the track in AutoTrack tracks structure. */
-	MovieTrackingTrack *track;  /* Pointer to an original track/ */
-	libmv_TrackRegionOptions track_region_options;  /* Options for the region
-	                                                   tracker. */
-	bool use_keyframe_match;  /* Keyframe pattern matching. */
-
-	/* TODO(sergey): A bit awkward to keep it in here, only used to
-	 * place a disabled marker once the tracking fails,
-	 * Wither find a more clear way to do it or call it track context
-	 * or state, not options.
-	 */
-	bool is_failed;
-	int failed_frame;
+  int clip_index;            /** Index of the clip this track belogs to. */
+  int track_index;           /* Index of the track in AutoTrack tracks structure. */
+  MovieTrackingTrack *track; /* Pointer to an original track/ */
+  libmv_TrackRegionOptions track_region_options; /* Options for the region
+                                                     tracker. */
+  bool use_keyframe_match;                       /* Keyframe pattern matching. */
+
+  /* TODO(sergey): A bit awkward to keep it in here, only used to
+   * place a disabled marker once the tracking fails,
+   * Wither find a more clear way to do it or call it track context
+   * or state, not options.
+   */
+  bool is_failed;
+  int failed_frame;
 } AutoTrackOptions;
 
 typedef struct AutoTrackContext {
-	MovieClip *clips[MAX_ACCESSOR_CLIP];
-	int num_clips;
+  MovieClip *clips[MAX_ACCESSOR_CLIP];
+  int num_clips;
 
-	MovieClipUser user;
-	int frame_width, frame_height;
+  MovieClipUser user;
+  int frame_width, frame_height;
 
-	struct libmv_AutoTrack *autotrack;
-	TrackingImageAccessor *image_accessor;
+  struct libmv_AutoTrack *autotrack;
+  TrackingImageAccessor *image_accessor;
 
-	int num_tracks;  /* Number of tracks being tracked. */
-	AutoTrackOptions *options;  /* Per-tracking track options. */
+  int num_tracks;            /* Number of tracks being tracked. */
+  AutoTrackOptions *options; /* Per-tracking track options. */
 
-	/* Array of all tracks, indexed by track_index. */
-	MovieTrackingTrack **tracks;
+  /* Array of all tracks, indexed by track_index. */
+  MovieTrackingTrack **tracks;
 
-	bool backwards;
-	bool sequence;
-	int first_frame;
-	int sync_frame;
-	bool first_sync;
-	SpinLock spin_lock;
+  bool backwards;
+  bool sequence;
+  int first_frame;
+  int sync_frame;
+  bool first_sync;
+  SpinLock spin_lock;
 
-	bool step_ok;
+  bool step_ok;
 } AutoTrackContext;
 
 static void normalized_to_libmv_frame(const float normalized[2],
                                       const int frame_dimensions[2],
                                       float result[2])
 {
-	result[0] = normalized[0] * frame_dimensions[0] - 0.5f;
-	result[1] = normalized[1] * frame_dimensions[1] - 0.5f;
+  result[0] = normalized[0] * frame_dimensions[0] - 0.5f;
+  result[1] = normalized[1] * frame_dimensions[1] - 0.5f;
 }
 
 static void normalized_relative_to_libmv_frame(const float normalized[2],
@@ -97,16 +97,16 @@ static void normalized_relative_to_libmv_frame(const float normalized[2],
                                                const int frame_dimensions[2],
                                                float result[2])
 {
-	result[0] = (normalized[0] + origin[0]) * frame_dimensions[0] - 0.5f;
-	result[1] = (normalized[1] + origin[1]) * frame_dimensions[1] - 0.5f;
+  result[0] = (normalized[0] + origin[0]) * frame_dimensions[0] - 0.5f;
+  result[1] = (normalized[1] + origin[1]) * frame_dimensions[1] - 0.5f;
 }
 
 static void libmv_frame_to_normalized(const float frame_coord[2],
                                       const int frame_dimensions[2],
                                       float result[2])
 {
-	result[0] = (frame_coord[0] + 0.5f) / frame_dimensions[0];
-	result[1] = (frame_coord[1] + 0.5f) / frame_dimensions[1];
+  result[0] = (frame_coord[0] + 0.5f) / frame_dimensions[0];
+  result[1] = (frame_coord[1] + 0.5f) / frame_dimensions[1];
 }
 
 static void libmv_frame_to_normalized_relative(const float frame_coord[2],
@@ -114,8 +114,8 @@ static void libmv_frame_to_normalized_relative(const float frame_coord[2],
                                                const int frame_dimensions[2],
                                                float result[2])
 {
-	result[0] = (frame_coord[0] - origin[0]) / frame_dimensions[0];
-	result[1] = (frame_coord[1] - origin[1]) / frame_dimensions[1];
+  result[0] = (frame_coord[0] - origin[0]) / frame_dimensions[0];
+  result[1] = (frame_coord[1] - origin[1]) / frame_dimensions[1];
 }
 
 static void dna_marker_to_libmv_marker(/*const*/ MovieTrackingTrack *track,
@@ -127,67 +127,55 @@ static void dna_marker_to_libmv_marker(/*const*/ MovieTrackingTrack *track,
                                        bool backwards,
                                        libmv_Marker *libmv_marker)
 {
-	const int frame_dimensions[2] = {frame_width, frame_height};
-	int i;
-	libmv_marker->clip = clip;
-	libmv_marker->frame = marker->framenr;
-	libmv_marker->track = track_index;
-
-	normalized_to_libmv_frame(marker->pos,
-	                          frame_dimensions,
-	                          libmv_marker->center);
-	for (i = 0; i < 4; ++i) {
-		normalized_relative_to_libmv_frame(marker->pattern_corners[i],
-		                                   marker->pos,
-		                                   frame_dimensions,
-		                                   libmv_marker->patch[i]);
-	}
-
-	normalized_relative_to_libmv_frame(marker->search_min,
-	                                   marker->pos,
-	                                   frame_dimensions,
-	                                   libmv_marker->search_region_min);
-
-	normalized_relative_to_libmv_frame(marker->search_max,
-	                                   marker->pos,
-	                                   frame_dimensions,
-	                                   libmv_marker->search_region_max);
-
-	/* TODO(sergey): All the markers does have 1.0 weight. */
-	libmv_marker->weight = 1.0f;
-
-	if (marker->flag & MARKER_TRACKED) {
-		libmv_marker->source = LIBMV_MARKER_SOURCE_TRACKED;
-	}
-	else {
-		libmv_marker->source = LIBMV_MARKER_SOURCE_MANUAL;
-	}
-	libmv_marker->status = LIBMV_MARKER_STATUS_UNKNOWN;
-	libmv_marker->model_type = LIBMV_MARKER_MODEL_TYPE_POINT;
-	libmv_marker->model_id = 0;
-
-	/* TODO(sergey): We currently don't support reference marker from
-	 * different clip.
-	 */
-	libmv_marker->reference_clip = clip;
-
-	if (track->pattern_match == TRACK_MATCH_KEYFRAME) {
-		MovieTrackingMarker *keyframe_marker =
-			tracking_get_keyframed_marker(track,
-			                              marker->framenr,
-			                              backwards);
-		libmv_marker->reference_frame = keyframe_marker->framenr;
-	}
-	else {
-		libmv_marker->reference_frame = backwards ?
-		                                marker->framenr - 1 :
-		                                marker->framenr;
-	}
-
-	libmv_marker->disabled_channels =
-	        ((track->flag & TRACK_DISABLE_RED)   ? LIBMV_MARKER_CHANNEL_R : 0) |
-	        ((track->flag & TRACK_DISABLE_GREEN) ? LIBMV_MARKER_CHANNEL_G : 0) |
-	        ((track->flag & TRACK_DISABLE_BLUE)  ? LIBMV_MARKER_CHANNEL_B : 0);
+  const int frame_dimensions[2] = {frame_width, frame_height};
+  int i;
+  libmv_marker->clip = clip;
+  libmv_marker->frame = marker->framenr;
+  libmv_marker->track = track_index;
+
+  normalized_to_libmv_frame(marker->pos, frame_dimensions, libmv_marker->center);
+  for (i = 0; i < 4; ++i) {
+    normalized_relative_to_libmv_frame(
+        marker->pattern_corners[i], marker->pos, frame_dimensions, libmv_marker->patch[i]);
+  }
+
+  normalized_relative_to_libmv_frame(
+      marker->search_min, marker->pos, frame_dimensions, libmv_marker->search_region_min);
+
+  normalized_relative_to_libmv_frame(
+      marker->search_max, marker->pos, frame_dimensions, libmv_marker->search_region_max);
+
+  /* TODO(sergey): All the markers does have 1.0 weight. */
+  libmv_marker->weight = 1.0f;
+
+  if (marker->flag & MARKER_TRACKED) {
+    libmv_marker->source = LIBMV_MARKER_SOURCE_TRACKED;
+  }
+  else {
+    libmv_marker->source = LIBMV_MARKER_SOURCE_MANUAL;
+  }
+  libmv_marker->status = LIBMV_MARKER_STATUS_UNKNOWN;
+  libmv_marker->model_type = LIBMV_MARKER_MODEL_TYPE_POINT;
+  libmv_marker->model_id = 0;
+
+  /* TODO(sergey): We currently don't support reference marker from
+   * different clip.
+   */
+  libmv_marker->reference_clip = clip;
+
+  if (track->pattern_match == TRACK_MATCH_KEYFRAME) {
+    MovieTrackingMarker *keyframe_marker = tracking_get_keyframed_marker(
+        track, marker->framenr, backwards);
+    libmv_marker->reference_frame = keyframe_marker->framenr;
+  }
+  else {
+    libmv_marker->reference_frame = backwards ? marker->framenr - 1 : marker->framenr;
+  }
+
+  libmv_marker->disabled_channels =
+      ((track->flag & TRACK_DISABLE_RED) ? LIBMV_MARKER_CHANNEL_R : 0) |
+      ((track->flag & TRACK_DISABLE_GREEN) ? LIBMV_MARKER_CHANNEL_G : 0) |
+      ((track->flag & TRACK_DISABLE_BLUE) ? LIBMV_MARKER_CHANNEL_B : 0);
 }
 
 static void libmv_marker_to_dna_marker(libmv_Marker *libmv_marker,
@@ -195,51 +183,43 @@ static void libmv_marker_to_dna_marker(libmv_Marker *libmv_marker,
                                        int frame_height,
                                        MovieTrackingMarker *marker)
 {
-	const int frame_dimensions[2] = {frame_width, frame_height};
-	int i;
-	marker->framenr = libmv_marker->frame;
-
-	libmv_frame_to_normalized(libmv_marker->center,
-	                          frame_dimensions,
-	                          marker->pos);
-	for (i = 0; i < 4; ++i) {
-		libmv_frame_to_normalized_relative(libmv_marker->patch[i],
-		                                   libmv_marker->center,
-		                                   frame_dimensions,
-		                                   marker->pattern_corners[i]);
-	}
-
-	libmv_frame_to_normalized_relative(libmv_marker->search_region_min,
-	                                   libmv_marker->center,
-	                                   frame_dimensions,
-	                                   marker->search_min);
-
-	libmv_frame_to_normalized_relative(libmv_marker->search_region_max,
-	                                   libmv_marker->center,
-	                                   frame_dimensions,
-	                                   marker->search_max);
-
-	marker->flag = 0;
-	if (libmv_marker->source == LIBMV_MARKER_SOURCE_TRACKED) {
-		marker->flag |= MARKER_TRACKED;
-	}
-	else {
-		marker->flag &= ~MARKER_TRACKED;
-	}
+  const int frame_dimensions[2] = {frame_width, frame_height};
+  int i;
+  marker->framenr = libmv_marker->frame;
+
+  libmv_frame_to_normalized(libmv_marker->center, frame_dimensions, marker->pos);
+  for (i = 0; i < 4; ++i) {
+    libmv_frame_to_normalized_relative(libmv_marker->patch[i],
+                                       libmv_marker->center,
+                                       frame_dimensions,
+                                       marker->pattern_corners[i]);
+  }
+
+  libmv_frame_to_normalized_relative(
+      libmv_marker->search_region_min, libmv_marker->center, frame_dimensions, marker->search_min);
+
+  libmv_frame_to_normalized_relative(
+      libmv_marker->search_region_max, libmv_marker->center, frame_dimensions, marker->search_max);
+
+  marker->flag = 0;
+  if (libmv_marker->source == LIBMV_MARKER_SOURCE_TRACKED) {
+    marker->flag |= MARKER_TRACKED;
+  }
+  else {
+    marker->flag &= ~MARKER_TRACKED;
+  }
 }
 
 static bool check_track_trackable(const MovieClip *clip,
                                   MovieTrackingTrack *track,
                                   const MovieClipUser *user)
 {
-	if (TRACK_SELECTED(track) &&
-	    (track->flag & (TRACK_LOCKED | TRACK_HIDDEN)) == 0)
-	{
-		int frame = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
-		const MovieTrackingMarker *marker = BKE_tracking_marker_get(track, frame);
-		return (marker->flag & MARKER_DISABLED) == 0;
-	}
-	return false;
+  if (TRACK_SELECTED(track) && (track->flag & (TRACK_LOCKED | TRACK_HIDDEN)) == 0) {
+    int frame = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
+    const MovieTrackingMarker *marker = BKE_tracking_marker_get(track, frame);
+    return (marker->flag & MARKER_DISABLED) == 0;
+  }
+  return false;
 }
 
 /* Returns false if marker crossed margin area from frame bounds. */
@@ -248,29 +228,28 @@ static bool tracking_check_marker_margin(libmv_Marker *libmv_marker,
                                          int frame_width,
                                          int frame_height)
 {
-	float patch_min[2], patch_max[2];
-	float margin_left, margin_top, margin_right, margin_bottom;
-
-	INIT_MINMAX2(patch_min, patch_max);
-	minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[0]);
-	minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[1]);
-	minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[2]);
-	minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[3]);
-
-	margin_left   = max_ff(libmv_marker->center[0] - patch_min[0], margin);
-	margin_top    = max_ff(patch_max[1] - libmv_marker->center[1], margin);
-	margin_right  = max_ff(patch_max[0] - libmv_marker->center[0], margin);
-	margin_bottom = max_ff(libmv_marker->center[1] - patch_min[1], margin);
-
-	if (libmv_marker->center[0] < margin_left ||
-	    libmv_marker->center[0] > frame_width - margin_right ||
-	    libmv_marker->center[1] < margin_bottom ||
-	    libmv_marker->center[1] > frame_height - margin_top)
-	{
-		return false;
-	}
-
-	return true;
+  float patch_min[2], patch_max[2];
+  float margin_left, margin_top, margin_right, margin_bottom;
+
+  INIT_MINMAX2(patch_min, patch_max);
+  minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[0]);
+  minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[1]);
+  minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[2]);
+  minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[3]);
+
+  margin_left = max_ff(libmv_marker->center[0] - patch_min[0], margin);
+  margin_top = max_ff(patch_max[1] - libmv_marker->center[1], margin);
+  margin_right = max_ff(patch_max[0] - libmv_marker->center[0], margin);
+  margin_bottom = max_ff(libmv_marker->center[1] - patch_min[1], margin);
+
+  if (libmv_marker->center[0] < margin_left ||
+      libmv_marker->center[0] > frame_width - margin_right ||
+      libmv_marker->center[1] < margin_bottom ||
+      libmv_marker->center[1] > frame_height - margin_top) {
+    return false;
+  }
+
+  return true;
 }
 
 /* Provide Libmv side of auto track all information about given tracks. */
@@ -280,56 +259,47 @@ static void fill_autotrack_tracks(const int frame_width,
                                   const bool backwards,
                                   struct libmv_AutoTrack *autotrack)
 {
-	/* Count number of markers to be put to a context. */
-	size_t num_trackable_markers = 0;
-	for (MovieTrackingTrack *track = tracksbase->first;
-	     track != NULL;
-	     track = track->next)
-	{
-		for (int i = 0; i < track->markersnr; ++i) {
-			const MovieTrackingMarker *marker = track->markers + i;
-			if ((marker->flag & MARKER_DISABLED) == 0) {
-				num_trackable_markers++;
-			}
-		}
-	}
-	/* Early output if we don't have any markers. */
-	if (num_trackable_markers == 0) {
-		return;
-	}
-	/* Allocate memory for all the markers. */
-	libmv_Marker *libmv_markers = MEM_mallocN(
-	        sizeof(libmv_Marker) * num_trackable_markers,
-	        "libmv markers array");
-	/* Fill in markers array. */
-	int track_index = 0, num_filled_libmv_markers = 0;
-	for (MovieTrackingTrack *track = tracksbase->first;
-	     track != NULL;
-	     track = track->next)
-	{
-		for (int i = 0; i < track->markersnr; ++i) {
-			MovieTrackingMarker *marker = track->markers + i;
-			if ((marker->flag & MARKER_DISABLED) != 0) {
-				continue;
-			}
-			dna_marker_to_libmv_marker(
-			        track,
-			        marker,
-			        0,
-			        track_index,
-			        frame_width, frame_height,
-			        backwards,
-			        &libmv_markers[num_filled_libmv_markers++]);
-		}
-		/* Put all markers to autotrack at once. */
-		track_index++;
-	}
-	/* Add all markers to autotrack. */
-	libmv_autoTrackSetMarkers(autotrack,
-	                          libmv_markers,
-	                          num_trackable_markers);
-	/* Free temporary memory. */
-	MEM_freeN(libmv_markers);
+  /* Count number of markers to be put to a context. */
+  size_t num_trackable_markers = 0;
+  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {
+    for (int i = 0; i < track->markersnr; ++i) {
+      const MovieTrackingMarker *marker = track->markers + i;
+      if ((marker->flag & MARKER_DISABLED) == 0) {
+        num_trackable_markers++;
+      }
+    }
+  }
+  /* Early output if we don't have any markers. */
+  if (num_trackable_markers == 0) {
+    return;
+  }
+  /* Allocate memory for all the markers. */
+  libmv_Marker *libmv_markers = MEM_mallocN(sizeof(libmv_Marker) * num_trackable_markers,
+                                            "libmv markers array");
+  /* Fill in markers array. */
+  int track_index = 0, num_filled_libmv_markers = 0;
+  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {
+    for (int i = 0; i < track->markersnr; ++i) {
+      MovieTrackingMarker *marker = track->markers + i;
+      if ((marker->flag & MARKER_DISABLED) != 0) {
+        continue;
+      }
+      dna_marker_to_libmv_marker(track,
+                                 marker,
+                                 0,
+                                 track_index,
+                                 frame_width,
+                                 frame_height,
+                                 backwards,
+                                 &libmv_markers[num_filled_libmv_markers++]);
+    }
+    /* Put all markers to autotrack at once. */
+    track_index++;
+  }
+  /* Add all markers to autotrack. */
+  libmv_autoTrackSetMarkers(autotrack, libmv_markers, num_trackable_markers);
+  /* Free temporary memory. */
+  MEM_freeN(libmv_markers);
 }
 
 static void create_per_track_tracking_options(const MovieClip *clip,
@@ -337,42 +307,32 @@ static void create_per_track_tracking_options(const MovieClip *clip,
                                               const ListBase *tracksbase,
                                               AutoTrackContext *context)
 {
-	/* Count number of trackable tracks. */
-	for (MovieTrackingTrack *track = tracksbase->first;
-	     track != NULL;
-	     track = track->next)
-	{
-		if (check_track_trackable(clip, track, user)) {
-			context->num_tracks++;
-		}
-	}
-	/* Allocate required memory. */
-	context->options =
-		MEM_callocN(sizeof(AutoTrackOptions) * context->num_tracks,
-		            "auto track options");
-	/* Fill in all the settings. */
-	int i = 0, track_index = 0;
-	for (MovieTrackingTrack *track = tracksbase->first;
-	     track != NULL;
-	     track = track->next)
-	{
-		if (!check_track_trackable(clip, track, user)) {
-			++track_index;
-			continue;
-		}
-		AutoTrackOptions *options = &context->options[i++];
-		/* TODO(sergey): Single clip only for now. */
-		options->clip_index = 0;
-		options->track_index = track_index;
-		options->track = track;
-		tracking_configure_tracker(track,
-		                           NULL,
-		                           &options->track_region_options);
-		options->use_keyframe_match =
-		        track->pattern_match == TRACK_MATCH_KEYFRAME;
-		context->tracks[track_index] = track;
-		++track_index;
-	}
+  /* Count number of trackable tracks. */
+  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {
+    if (check_track_trackable(clip, track, user)) {
+      context->num_tracks++;
+    }
+  }
+  /* Allocate required memory. */
+  context->options = MEM_callocN(sizeof(AutoTrackOptions) * context->num_tracks,
+                                 "auto track options");
+  /* Fill in all the settings. */
+  int i = 0, track_index = 0;
+  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {
+    if (!check_track_trackable(clip, track, user)) {
+      ++track_index;
+      continue;
+    }
+    AutoTrackOptions *options = &context->options[i++];
+    /* TODO(sergey): Single clip only for now. */
+    options->clip_index = 0;
+    options->track_index = track_index;
+    options->track = track;
+    tracking_configure_tracker(track, NULL, &options->track_region_options);
+    options->use_keyframe_match = track->pattern_match == TRACK_MATCH_KEYFRAME;
+    context->tracks[track_index] = track;
+    ++track_index;
+  }
 }
 
 AutoTrackContext *BKE_autotrack_context_new(MovieClip *clip,
@@ -380,266 +340,217 @@ AutoTrackContext *BKE_autotrack_context_new(MovieClip *clip,
                                             const bool backwards,
                                             const bool sequence)
 {
-	AutoTrackContext *context = MEM_callocN(sizeof(AutoTrackContext),
-	                                        "autotrack context");
-	MovieTracking *tracking = &clip->tracking;
-	ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
-	int frame_width, frame_height;
-	/* get size of frame to convert normalized coordinates to a picture ones. */
-	BKE_movieclip_get_size(clip, user, &frame_width, &frame_height);
-	/* TODO(sergey): Currently using only a single clip. */
-	context->clips[0] = clip;
-	context->num_clips = 1;
-	context->user = *user;
-	context->user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
-	context->user.render_flag = 0;
-	context->frame_width = frame_width;
-	context->frame_height = frame_height;
-	context->backwards = backwards;
-	context->sequence = sequence;
-	context->first_frame = user->framenr;
-	context->sync_frame = user->framenr;
-	context->first_sync = true;
-	BLI_spin_init(&context->spin_lock);
-	const int num_total_tracks = BLI_listbase_count(tracksbase);
-	context->tracks =
-	        MEM_callocN(sizeof(MovieTrackingTrack *) * num_total_tracks,
-	                    "auto track pointers");
-	/* Initialize image accessor. */
-	context->image_accessor =
-		tracking_image_accessor_new(context->clips, 1,
-		                            context->tracks, num_total_tracks,
-		                            user->framenr);
-	/* Initialize auto track context and provide all information about currently
-	 * tracked markers.
-	 */
-	context->autotrack =
-	        libmv_autoTrackNew(context->image_accessor->libmv_accessor);
-	fill_autotrack_tracks(frame_width, frame_height,
-	                      tracksbase,
-	                      backwards,
-	                      context->autotrack);
-	/* Create per-track tracking options. */
-	create_per_track_tracking_options(clip, user, tracksbase, context);
-	return context;
+  AutoTrackContext *context = MEM_callocN(sizeof(AutoTrackContext), "autotrack context");
+  MovieTracking *tracking = &clip->tracking;
+  ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
+  int frame_width, frame_height;
+  /* get size of frame to convert normalized coordinates to a picture ones. */
+  BKE_movieclip_get_size(clip, user, &frame_width, &frame_height);
+  /* TODO(sergey): Currently using only a single clip. */
+  context->clips[0] = clip;
+  context->num_clips = 1;
+  context->user = *user;
+  context->user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
+  context->user.render_flag = 0;
+  context->frame_width = frame_width;
+  context->frame_height = frame_height;
+  context->backwards = backwards;
+  context->sequence = sequence;
+  context->first_frame = user->framenr;
+  context->sync_frame = user->framenr;
+  context->first_sync = true;
+  BLI_spin_init(&context->spin_lock);
+  const int num_total_tracks = BLI_listbase_count(tracksbase);
+  context->tracks = MEM_callocN(sizeof(MovieTrackingTrack *) * num_total_tracks,
+                                "auto track pointers");
+  /* Initialize image accessor. */
+  context->image_accessor = tracking_image_accessor_new(
+      context->clips, 1, context->tracks, num_total_tracks, user->framenr);
+  /* Initialize auto track context and provide all information about currently
+   * tracked markers.
+   */
+  context->autotrack = libmv_autoTrackNew(context->image_accessor->libmv_accessor);
+  fill_autotrack_tracks(frame_width, frame_height, tracksbase, backwards, context->autotrack);
+  /* Create per-track tracking options. */
+  create_per_track_tracking_options(clip, user, tracksbase, context);
+  return context;
 }
 
-static void autotrack_context_step_cb(
-        void *__restrict userdata,
-        const int track,
-        const ParallelRangeTLS *__restrict UNUSED(tls))
+static void autotrack_context_step_cb(void *__restrict userdata,
+                                      const int track,
+                                      const ParallelRangeTLS *__restrict UNUSED(tls))
 {
-	AutoTrackContext *context = userdata;
-	const int frame_delta = context->backwards ? -1 : 1;
-
-	AutoTrackOptions *options = &context->options[track];
-	if (options->is_failed) {
-		return;
-	}
-	libmv_Marker libmv_current_marker,
-	             libmv_reference_marker,
-	             libmv_tracked_marker;
-	libmv_TrackRegionResult libmv_result;
-	const int frame = BKE_movieclip_remap_scene_to_clip_frame(
-	        context->clips[options->clip_index],
-	        context->user.framenr);
-	BLI_spin_lock(&context->spin_lock);
-	const bool has_marker = libmv_autoTrackGetMarker(context->autotrack,
-	                                                 options->clip_index,
-	                                                 frame,
-	                                                 options->track_index,
-	                                                 &libmv_current_marker);
-	BLI_spin_unlock(&context->spin_lock);
-	/* Check whether we've got marker to sync with. */
-	if (!has_marker) {
-		return;
-	}
-	/* Check whether marker is going outside of allowed frame margin. */
-	if (!tracking_check_marker_margin(&libmv_current_marker,
-	                                  options->track->margin,
-	                                  context->frame_width,
-	                                  context->frame_height))
-	{
-		return;
-	}
-	libmv_tracked_marker = libmv_current_marker;
-	libmv_tracked_marker.frame = frame + frame_delta;
-	/* Update reference frame. */
-	if (options->use_keyframe_match) {
-		libmv_tracked_marker.reference_frame =
-		        libmv_current_marker.reference_frame;
-		libmv_autoTrackGetMarker(context->autotrack,
-	                             options->clip_index,
-	                             libmv_tracked_marker.reference_frame,
-	                             options->track_index,
-	                             &libmv_reference_marker);
-	}
-	else {
-		libmv_tracked_marker.reference_frame = frame;
-		libmv_reference_marker = libmv_current_marker;
-	}
-	/* Perform actual tracking. */
-	if (libmv_autoTrackMarker(context->autotrack,
-	                          &options->track_region_options,
-	                          &libmv_tracked_marker,
-	                          &libmv_result))
-	{
-		BLI_spin_lock(&context->spin_lock);
-		libmv_autoTrackAddMarker(context->autotrack, &libmv_tracked_marker);
-		BLI_spin_unlock(&context->spin_lock);
-	}
-	else {
-		options->is_failed = true;
-		options->failed_frame = frame + frame_delta;
-	}
-
-	/* Note: Atomic is probably not actually needed here, I doubt we could get
-	 *       any other result than a true bool anyway.
-	 *       But for sake of consistency, and since it costs nothing...
-	 */
-	atomic_fetch_and_or_uint8((uint8_t *)&context->step_ok, true);
+  AutoTrackContext *context = userdata;
+  const int frame_delta = context->backwards ? -1 : 1;
+
+  AutoTrackOptions *options = &context->options[track];
+  if (options->is_failed) {
+    return;
+  }
+  libmv_Marker libmv_current_marker, libmv_reference_marker, libmv_tracked_marker;
+  libmv_TrackRegionResult libmv_result;
+  const int frame = BKE_movieclip_remap_scene_to_clip_frame(context->clips[options->clip_index],
+                                                            context->user.framenr);
+  BLI_spin_lock(&context->spin_lock);
+  const bool has_marker = libmv_autoTrackGetMarker(
+      context->autotrack, options->clip_index, frame, options->track_index, &libmv_current_marker);
+  BLI_spin_unlock(&context->spin_lock);
+  /* Check whether we've got marker to sync with. */
+  if (!has_marker) {
+    return;
+  }
+  /* Check whether marker is going outside of allowed frame margin. */
+  if (!tracking_check_marker_margin(&libmv_current_marker,
+                                    options->track->margin,
+                                    context->frame_width,
+                                    context->frame_height)) {
+    return;
+  }
+  libmv_tracked_marker = libmv_current_marker;
+  libmv_tracked_marker.frame = frame + frame_delta;
+  /* Update reference frame. */
+  if (options->use_keyframe_match) {
+    libmv_tracked_marker.reference_frame = libmv_current_marker.reference_frame;
+    libmv_autoTrackGetMarker(context->autotrack,
+                             options->clip_index,
+                             libmv_tracked_marker.reference_frame,
+                             options->track_index,
+                             &libmv_reference_marker);
+  }
+  else {
+    libmv_tracked_marker.reference_frame = frame;
+    libmv_reference_marker = libmv_current_marker;
+  }
+  /* Perform actual tracking. */
+  if (libmv_autoTrackMarker(context->autotrack,
+                            &options->track_region_options,
+                            &libmv_tracked_marker,
+                            &libmv_result)) {
+    BLI_spin_lock(&context->spin_lock);
+    libmv_autoTrackAddMarker(context->autotrack, &libmv_tracked_marker);
+    BLI_spin_unlock(&context->spin_lock);
+  }
+  else {
+    options->is_failed = true;
+    options->failed_frame = frame + frame_delta;
+  }
+
+  /* Note: Atomic is probably not actually needed here, I doubt we could get
+   *       any other result than a true bool anyway.
+   *       But for sake of consistency, and since it costs nothing...
+   */
+  atomic_fetch_and_or_uint8((uint8_t *)&context->step_ok, true);
 }
 
 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,
-	                        &settings);
-
-	/* Advance the frame. */
-	BLI_spin_lock(&context->spin_lock);
-	context->user.framenr += frame_delta;
-	BLI_spin_unlock(&context->spin_lock);
-	return context->step_ok;
+  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, &settings);
+
+  /* Advance the frame. */
+  BLI_spin_lock(&context->spin_lock);
+  context->user.framenr += frame_delta;
+  BLI_spin_unlock(&context->spin_lock);
+  return context->step_ok;
 }
 
 void BKE_autotrack_context_sync(AutoTrackContext *context)
 {
-	int newframe, frame_delta = context->backwards ? -1 : 1;
-	int frame;
-
-	BLI_spin_lock(&context->spin_lock);
-	newframe = context->user.framenr;
-	for (frame = context->sync_frame;
-	     frame != (context->backwards ? newframe - 1 : newframe + 1);
-	     frame += frame_delta)
-	{
-		MovieTrackingMarker marker;
-		libmv_Marker libmv_marker;
-		int clip = 0;
-		int track;
-		for (track = 0; track < context->num_tracks; ++track) {
-			AutoTrackOptions *options = &context->options[track];
-			int track_frame = BKE_movieclip_remap_scene_to_clip_frame(
-			        context->clips[options->clip_index], frame);
-			if (options->is_failed) {
-				if (options->failed_frame == track_frame) {
-					MovieTrackingMarker *prev_marker =
-					        BKE_tracking_marker_get_exact(
-					                options->track,
-					                context->backwards
-					                        ? frame + 1
-					                        : frame - 1);
-					if (prev_marker) {
-						marker = *prev_marker;
-						marker.framenr = track_frame;
-						marker.flag |= MARKER_DISABLED;
-						BKE_tracking_marker_insert(options->track, &marker);
-						continue;
-					}
-				}
-				if ((context->backwards && options->failed_frame > track_frame) ||
-				    (!context->backwards && options->failed_frame < track_frame))
-				{
-					continue;
-				}
-			}
-			if (libmv_autoTrackGetMarker(context->autotrack,
-			                             clip,
-			                             track_frame,
-			                             options->track_index,
-			                             &libmv_marker))
-			{
-				libmv_marker_to_dna_marker(&libmv_marker,
-				                           context->frame_width,
-				                           context->frame_height,
-				                           &marker);
-				if (context->first_sync && frame == context->sync_frame) {
-					tracking_marker_insert_disabled(options->track,
-					                                &marker,
-					                                !context->backwards,
-					                                false);
-				}
-				BKE_tracking_marker_insert(options->track, &marker);
-				tracking_marker_insert_disabled(options->track,
-				                                &marker,
-				                                context->backwards,
-				                                false);
-			}
-		}
-	}
-	BLI_spin_unlock(&context->spin_lock);
-
-	for (int clip = 0; clip < context->num_clips; ++clip) {
-		MovieTracking *tracking = &context->clips[clip]->tracking;
-		BKE_tracking_dopesheet_tag_update(tracking);
-	}
-
-	context->sync_frame = newframe;
-	context->first_sync = false;
+  int newframe, frame_delta = context->backwards ? -1 : 1;
+  int frame;
+
+  BLI_spin_lock(&context->spin_lock);
+  newframe = context->user.framenr;
+  for (frame = context->sync_frame; frame != (context->backwards ? newframe - 1 : newframe + 1);
+       frame += frame_delta) {
+    MovieTrackingMarker marker;
+    libmv_Marker libmv_marker;
+    int clip = 0;
+    int track;
+    for (track = 0; track < context->num_tracks; ++track) {
+      AutoTrackOptions *options = &context->options[track];
+      int track_frame = BKE_movieclip_remap_scene_to_clip_frame(
+          context->clips[options->clip_index], frame);
+      if (options->is_failed) {
+        if (options->failed_frame == track_frame) {
+          MovieTrackingMarker *prev_marker = BKE_tracking_marker_get_exact(
+              options->track, context->backwards ? frame + 1 : frame - 1);
+          if (prev_marker) {
+            marker = *prev_marker;
+            marker.framenr = track_frame;
+            marker.flag |= MARKER_DISABLED;
+            BKE_tracking_marker_insert(options->track, &marker);
+            continue;
+          }
+        }
+        if ((context->backwards && options->failed_frame > track_frame) ||
+            (!context->backwards && options->failed_frame < track_frame)) {
+          continue;
+        }
+      }
+      if (libmv_autoTrackGetMarker(
+              context->autotrack, clip, track_frame, options->track_index, &libmv_marker)) {
+        libmv_marker_to_dna_marker(
+            &libmv_marker, context->frame_width, context->frame_height, &marker);
+        if (context->first_sync && frame == context->sync_frame) {
+          tracking_marker_insert_disabled(options->track, &marker, !context->backwards, false);
+        }
+        BKE_tracking_marker_insert(options->track, &marker);
+        tracking_marker_insert_disabled(options->track, &marker, context->backwards, false);
+      }
+    }
+  }
+  BLI_spin_unlock(&context->spin_lock);
+
+  for (int clip = 0; clip < context->num_clips; ++clip) {
+    MovieTracking *tracking = &context->clips[clip]->tracking;
+    BKE_tracking_dopesheet_tag_update(tracking);
+  }
+
+  context->sync_frame = newframe;
+  context->first_sync = false;
 }
 
-void BKE_autotrack_context_sync_user(AutoTrackContext *context,
-                                     MovieClipUser *user)
+void BKE_autotrack_context_sync_user(AutoTrackContext *context, MovieClipUser *user)
 {
-	user->framenr = context->sync_frame;
+  user->framenr = context->sync_frame;
 }
 
 void BKE_autotrack_context_finish(AutoTrackContext *context)
 {
-	int clip_index;
-
-	for (clip_index = 0; clip_index < context->num_clips; ++clip_index) {
-		MovieClip *clip = context->clips[clip_index];
-		ListBase *plane_tracks_base =
-			BKE_tracking_get_active_plane_tracks(&clip->tracking);
-		MovieTrackingPlaneTrack *plane_track;
-
-		for (plane_track = plane_tracks_base->first;
-		     plane_track;
-		     plane_track = plane_track->next)
-		{
-			if ((plane_track->flag & PLANE_TRACK_AUTOKEY) == 0) {
-				int track;
-				for (track = 0; track < context->num_tracks; ++track) {
-					if (BKE_tracking_plane_track_has_point_track(
-					            plane_track,
-					            context->options[track].track))
-					{
-						BKE_tracking_track_plane_from_existing_motion(
-						        plane_track,
-						        context->first_frame);
-						break;
-					}
-				}
-			}
-		}
-	}
+  int clip_index;
+
+  for (clip_index = 0; clip_index < context->num_clips; ++clip_index) {
+    MovieClip *clip = context->clips[clip_index];
+    ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
+    MovieTrackingPlaneTrack *plane_track;
+
+    for (plane_track = plane_tracks_base->first; plane_track; plane_track = plane_track->next) {
+      if ((plane_track->flag & PLANE_TRACK_AUTOKEY) == 0) {
+        int track;
+        for (track = 0; track < context->num_tracks; ++track) {
+          if (BKE_tracking_plane_track_has_point_track(plane_track,
+                                                       context->options[track].track)) {
+            BKE_tracking_track_plane_from_existing_motion(plane_track, context->first_frame);
+            break;
+          }
+        }
+      }
+    }
+  }
 }
 
 void BKE_autotrack_context_free(AutoTrackContext *context)
 {
-	libmv_autoTrackDestroy(context->autotrack);
-	tracking_image_accessor_destroy(context->image_accessor);
-	MEM_freeN(context->options);
-	MEM_freeN(context->tracks);
-	BLI_spin_end(&context->spin_lock);
-	MEM_freeN(context);
+  libmv_autoTrackDestroy(context->autotrack);
+  tracking_image_accessor_destroy(context->image_accessor);
+  MEM_freeN(context->options);
+  MEM_freeN(context->tracks);
+  BLI_spin_end(&context->spin_lock);
+  MEM_freeN(context);
 }