Internal refactoring of tracking module, should be no functional changes

- Re-arrange functions in headers and implementation file to make them
  more grouped by entity they're operating with. Also order of functions
  in implementation file should match order of functions in header for
  easier navigation.

- Rename some functions to match conventions of naming public functions.
- Some code de-duplication, still some room for improvements tho.
- Split main 2D tracking functions into smaller steps to make it more clear.

Accidentally OpenMP was disabled in some of previous commits, re-enable it.

5 files changed, 1704 insertions, 1588 deletions

diff --git a/source/blender/blenkernel/BKE_tracking.h b/source/blender/blenkernel/BKE_tracking.h
index e6c98c72b55..2b30c845754 100644
--- a/source/blender/blenkernel/BKE_tracking.h
+++ b/source/blender/blenkernel/BKE_tracking.h
@@ -47,127 +47,159 @@ struct Camera;
 struct Object;
 struct Scene;
 
-void BKE_tracking_init_settings(struct MovieTracking *tracking);
-void BKE_tracking_clamp_marker(struct MovieTrackingMarker *marker, int event);
-void BKE_tracking_track_flag(struct MovieTrackingTrack *track, int area, int flag, int clear);
+/* **** Common functions **** */
 
-struct MovieTrackingTrack *BKE_tracking_add_track(struct MovieTracking *tracking, struct ListBase *tracksbase,
+void BKE_tracking_free(struct MovieTracking *tracking);
+
+void BKE_tracking_settings_init(struct MovieTracking *tracking);
+
+struct ListBase *BKE_tracking_get_active_tracks(struct MovieTracking *tracking);
+struct MovieTrackingReconstruction *BKE_tracking_get_active_reconstruction(struct MovieTracking *tracking);
+
+/* matrices for constraints and drawing */
+void BKE_tracking_get_camera_object_matrix(struct Scene *scene, struct Object *ob, float mat[4][4]);
+void BKE_tracking_get_projection_matrix(struct MovieTracking *tracking, struct MovieTrackingObject *object,
+                                        int framenr, int winx, int winy, float mat[4][4]);
+
+/* **** Clipboard **** */
+void BKE_tracking_clipboard_free(void);
+void BKE_tracking_clipboard_copy_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
+int BKE_tracking_clipboard_has_tracks(void);
+void BKE_tracking_clipboard_paste_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
+
+/* **** Track **** */
+struct MovieTrackingTrack *BKE_tracking_track_add(struct MovieTracking *tracking, struct ListBase *tracksbase,
                                                   float x, float y, int framenr, int width, int height);
-struct MovieTrackingMarker *BKE_tracking_insert_marker(struct MovieTrackingTrack *track,
+void BKE_tracking_track_unique_name(struct ListBase *tracksbase, struct MovieTrackingTrack *track);
+void BKE_tracking_track_free(struct MovieTrackingTrack *track);
+
+void BKE_tracking_track_flag_set(struct MovieTrackingTrack *track, int area, int flag);
+void BKE_tracking_track_flag_clear(struct MovieTrackingTrack *track, int area, int flag);
+
+int BKE_tracking_track_has_marker_at_frame(struct MovieTrackingTrack *track, int framenr);
+int BKE_tracking_track_has_enabled_marker_at_frame(struct MovieTrackingTrack *track, int framenr);
+
+void BKE_tracking_track_path_clear(struct MovieTrackingTrack *track, int ref_frame, int action);
+void BKE_tracking_tracks_join(struct MovieTrackingTrack *dst_track, struct MovieTrackingTrack *src_track);
+
+struct MovieTrackingTrack *BKE_tracking_track_get_named(struct MovieTracking *tracking,
+                                                        struct MovieTrackingObject *object,
+                                                        const char *name);
+struct MovieTrackingTrack *BKE_tracking_track_get_indexed(struct MovieTracking *tracking, int tracknr,
+                                                          struct ListBase **tracksbase_r);
+
+struct MovieTrackingTrack *BKE_tracking_track_get_active(struct MovieTracking *tracking);
+
+float *BKE_tracking_track_get_mask(int frame_width, int frame_height, struct MovieTrackingTrack *track,
+                                   struct MovieTrackingMarker *marker);
+
+/* selection */
+void BKE_tracking_track_select(struct ListBase *tracksbase, struct MovieTrackingTrack *track, int area, int extend);
+void BKE_tracking_track_deselect(struct MovieTrackingTrack *track, int area);
+
+/* **** Marker **** */
+struct MovieTrackingMarker *BKE_tracking_marker_insert(struct MovieTrackingTrack *track,
                                                        struct MovieTrackingMarker *marker);
-void BKE_tracking_delete_marker(struct MovieTrackingTrack *track, int framenr);
+void BKE_tracking_marker_delete(struct MovieTrackingTrack *track, int framenr);
+
+void BKE_tracking_marker_clamp(struct MovieTrackingMarker *marker, int event);
+
+struct MovieTrackingMarker *BKE_tracking_marker_get(struct MovieTrackingTrack *track, int framenr);
+struct MovieTrackingMarker *BKE_tracking_marker_get_exact(struct MovieTrackingTrack *track, int framenr);
+struct MovieTrackingMarker *BKE_tracking_marker_ensure(struct MovieTrackingTrack *track, int framenr);
 
 void BKE_tracking_marker_pattern_minmax(const struct MovieTrackingMarker *marker, float min[2], float max[2]);
-struct MovieTrackingMarker *BKE_tracking_get_marker(struct MovieTrackingTrack *track, int framenr);
-struct MovieTrackingMarker *BKE_tracking_ensure_marker(struct MovieTrackingTrack *track, int framenr);
-struct MovieTrackingMarker *BKE_tracking_exact_marker(struct MovieTrackingTrack *track, int framenr);
-int BKE_tracking_has_marker(struct MovieTrackingTrack *track, int framenr);
-int BKE_tracking_has_enabled_marker(struct MovieTrackingTrack *track, int framenr);
 
-void BKE_tracking_free_track(struct MovieTrackingTrack *track);
+/* **** Object **** */
+struct MovieTrackingObject *BKE_tracking_object_add(struct MovieTracking *tracking, const char *name);
+void BKE_tracking_object_delete(struct MovieTracking *tracking, struct MovieTrackingObject *object);
 
-void BKE_tracking_clear_path(struct MovieTrackingTrack *track, int ref_frame, int action);
+void BKE_tracking_object_unique_name(struct MovieTracking *tracking, struct MovieTrackingObject *object);
 
-void BKE_tracking_join_tracks(struct MovieTrackingTrack *dst_track, struct MovieTrackingTrack *src_track);
-void BKE_tracking_free(struct MovieTracking *tracking);
+struct MovieTrackingObject *BKE_tracking_object_get_named(struct MovieTracking *tracking, const char *name);
 
-struct ImBuf *BKE_tracking_sample_pattern_imbuf(int frame_width, int frame_height,
-                                                struct ImBuf *struct_ibuf, struct MovieTrackingTrack *track,
-                                                struct MovieTrackingMarker *marker, int use_mask,
-                                                int num_samples_x, int num_samples_y, float pos[2]);
-struct ImBuf *BKE_tracking_get_pattern_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
-                                             struct MovieTrackingMarker *marker, int anchored, int disable_channels);
-struct ImBuf *BKE_tracking_get_search_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
-                                            struct MovieTrackingMarker *marker, int anchored, int disable_channels);
-float *BKE_tracking_track_mask_get(int frame_width, int frame_height, struct MovieTrackingTrack *track,
-                                   struct MovieTrackingMarker *marker);
+struct MovieTrackingObject *BKE_tracking_object_get_active(struct MovieTracking *tracking);
+struct MovieTrackingObject *BKE_tracking_object_get_camera(struct MovieTracking *tracking);
 
-void BKE_track_unique_name(struct ListBase *tracksbase, struct MovieTrackingTrack *track);
+struct ListBase *BKE_tracking_object_get_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
+struct MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(struct MovieTracking *tracking,
+                                                                           struct MovieTrackingObject *object);
 
-struct MovieTrackingTrack *BKE_tracking_named_track(struct MovieTracking *tracking, struct MovieTrackingObject *object, const char *name);
-struct MovieTrackingTrack *BKE_tracking_indexed_track(struct MovieTracking *tracking, int tracknr, struct ListBase **tracksbase_r);
+/* **** Camera **** */
+void BKE_tracking_camera_shift_get(struct MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty);
+void BKE_tracking_camera_to_blender(struct MovieTracking *tracking, struct Scene *scene,
+                                    struct Camera *camera, int width, int height);
 
-void BKE_tracking_camera_shift(struct MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty);
-void BKE_tracking_camera_to_blender(struct MovieTracking *tracking, struct Scene *scene, struct Camera *camera, int width, int height);
+struct MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(struct MovieTracking *tracking,
+                                                                       struct MovieTrackingObject *object,
+                                                                       int framenr);
+void BKE_tracking_camera_get_reconstructed_interpolate(struct MovieTracking *tracking,
+                                                       struct MovieTrackingObject *object,
+                                                       int framenr, float mat[4][4]);
 
-void BKE_get_tracking_mat(struct Scene *scene, struct Object *ob, float mat[4][4]);
-void BKE_tracking_projection_matrix(struct MovieTracking *tracking, struct MovieTrackingObject *object,
-                                    int framenr, int winx, int winy, float mat[4][4]);
+/* **** Distortion/Undistortion **** */
+struct MovieDistortion *BKE_tracking_distortion_new(void);
+void BKE_tracking_distortion_update(struct MovieDistortion *distortion, struct MovieTracking *tracking,
+                                    int calibration_width, int calibration_height);
+struct MovieDistortion *BKE_tracking_distortion_copy(struct MovieDistortion *distortion);
+struct ImBuf *BKE_tracking_distortion_exec(struct MovieDistortion *distortion, struct MovieTracking *tracking,
+                                           struct ImBuf *ibuf, int width, int height, float overscan, int undistort);
+void BKE_tracking_distortion_free(struct MovieDistortion *distortion);
 
-struct ListBase *BKE_tracking_get_tracks(struct MovieTracking *tracking);
-struct MovieTrackingReconstruction *BKE_tracking_get_reconstruction(struct MovieTracking *tracking);
+void BKE_tracking_distort_v2(struct MovieTracking *tracking, float co[2], float nco[2]);
+void BKE_tracking_undistort_v2(struct MovieTracking *tracking, float co[2], float nco[2]);
 
-struct MovieTrackingTrack *BKE_tracking_active_track(struct MovieTracking *tracking);
-struct MovieTrackingObject *BKE_tracking_active_object(struct MovieTracking *tracking);
-struct MovieTrackingObject *BKE_tracking_get_camera_object(struct MovieTracking *tracking);
-struct ListBase *BKE_tracking_object_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
-struct MovieTrackingReconstruction *BKE_tracking_object_reconstruction(struct MovieTracking *tracking,
-                                                                       struct MovieTrackingObject *object);
+struct ImBuf *BKE_tracking_undistort_frame(struct MovieTracking *tracking, struct ImBuf *ibuf,
+                                           int calibration_width, int calibration_height, float overscan);
+struct ImBuf *BKE_tracking_distort_frame(struct MovieTracking *tracking, struct ImBuf *ibuf,
+                                         int calibration_width, int calibration_height, float overscan);
 
-void BKE_tracking_disable_imbuf_channels(struct ImBuf *ibuf, int disable_red, int disable_green, int disable_blue, int grayscale);
+/* **** Image sampling **** */
+struct ImBuf *BKE_tracking_sample_pattern(int frame_width, int frame_height,
+                                          struct ImBuf *struct_ibuf, struct MovieTrackingTrack *track,
+                                          struct MovieTrackingMarker *marker, int use_mask,
+                                          int num_samples_x, int num_samples_y, float pos[2]);
+struct ImBuf *BKE_tracking_get_pattern_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
+                                             struct MovieTrackingMarker *marker, int anchored, int disable_channels);
+struct ImBuf *BKE_tracking_get_search_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
+                                            struct MovieTrackingMarker *marker, int anchored, int disable_channels);
 
-/* clipboard */
-void BKE_tracking_free_clipboard(void);
-void BKE_tracking_clipboard_copy_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
-int BKE_tracking_clipboard_has_tracks(void);
-void BKE_tracking_clipboard_paste_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
+void BKE_tracking_disable_channels(struct ImBuf *ibuf, int disable_red, int disable_green,
+                                   int disable_blue, int grayscale);
 
-/* 2D tracking */
+/* **** 2D tracking **** */
 struct MovieTrackingContext *BKE_tracking_context_new(struct MovieClip *clip, struct MovieClipUser *user,
                                                       short backwards, short sequence);
 void BKE_tracking_context_free(struct MovieTrackingContext *context);
-void BKE_tracking_sync(struct MovieTrackingContext *context);
-void BKE_tracking_sync_user(struct MovieClipUser *user, struct MovieTrackingContext *context);
-int BKE_tracking_next(struct MovieTrackingContext *context);
+void BKE_tracking_context_sync(struct MovieTrackingContext *context);
+void BKE_tracking_context_sync_user(const struct MovieTrackingContext *context, struct MovieClipUser *user);
+int BKE_tracking_context_step(struct MovieTrackingContext *context);
 
-/* Camera solving */
-int BKE_tracking_can_reconstruct(struct MovieTracking *tracking, struct MovieTrackingObject *object,
-                                 char *error_msg, int error_size);
+/* **** Camera solving **** */
+int BKE_tracking_reconstruction_check(struct MovieTracking *tracking, struct MovieTrackingObject *object,
+                                      char *error_msg, int error_size);
 
 struct MovieReconstructContext *BKE_tracking_reconstruction_context_new(struct MovieTracking *tracking,
-                                                                        struct MovieTrackingObject *object, int keyframe1, int keyframe2, int width, int height);
+                                                                        struct MovieTrackingObject *object,
+                                                                        int keyframe1, int keyframe2,
+                                                                        int width, int height);
 void BKE_tracking_reconstruction_context_free(struct MovieReconstructContext *context);
-void BKE_tracking_solve_reconstruction(struct MovieReconstructContext *context, short *stop, short *do_update,
+void BKE_tracking_reconstruction_solve(struct MovieReconstructContext *context, short *stop, short *do_update,
                                        float *progress, char *stats_message, int message_size);
-int BKE_tracking_finish_reconstruction(struct MovieReconstructContext *context, struct MovieTracking *tracking);
-
-struct MovieReconstructedCamera *BKE_tracking_get_reconstructed_camera(struct MovieTracking *tracking,
-                                                                       struct MovieTrackingObject *object, int framenr);
-void BKE_tracking_get_interpolated_camera(struct MovieTracking *tracking, struct MovieTrackingObject *object,
-                                          int framenr, float mat[4][4]);
+int BKE_tracking_reconstruction_finish(struct MovieReconstructContext *context, struct MovieTracking *tracking);
 
-/* Feature detection */
+/* **** Feature detection **** */
 void BKE_tracking_detect_fast(struct MovieTracking *tracking, struct ListBase *tracksbase, struct ImBuf *imbuf,
                               int framenr, int margin, int min_trackness, int min_distance, struct bGPDlayer *layer,
                               int place_outside_layer);
 
-/* 2D stabilization */
-void BKE_tracking_stabilization_data(struct MovieTracking *tracking, int framenr, int width, int height, float loc[2], float *scale, float *angle);
-struct ImBuf *BKE_tracking_stabilize(struct MovieTracking *tracking, int framenr, struct ImBuf *ibuf, float loc[2], float *scale, float *angle);
-void BKE_tracking_stabdata_to_mat4(int width, int height, float aspect, float loc[2], float scale, float angle, float mat[4][4]);
-
-/* Distortion/Undistortion */
-void BKE_tracking_apply_intrinsics(struct MovieTracking *tracking, float co[2], float nco[2]);
-void BKE_tracking_invert_intrinsics(struct MovieTracking *tracking, float co[2], float nco[2]);
-
-struct MovieDistortion *BKE_tracking_distortion_create(void);
-struct MovieDistortion *BKE_tracking_distortion_copy(struct MovieDistortion *distortion);
-struct ImBuf *BKE_tracking_distortion_exec(struct MovieDistortion *distortion, struct MovieTracking *tracking,
-                                           struct ImBuf *ibuf, int width, int height, float overscan, int undistort);
-void BKE_tracking_distortion_destroy(struct MovieDistortion *distortion);
-
-struct ImBuf *BKE_tracking_undistort(struct MovieTracking *tracking, struct ImBuf *ibuf, int width, int height, float overscan);
-struct ImBuf *BKE_tracking_distort(struct MovieTracking *tracking, struct ImBuf *ibuf, int width, int height, float overscan);
-
-/* Object tracking */
-struct MovieTrackingObject *BKE_tracking_new_object(struct MovieTracking *tracking, const char *name);
-void BKE_tracking_remove_object(struct MovieTracking *tracking, struct MovieTrackingObject *object);
-void BKE_tracking_object_unique_name(struct MovieTracking *tracking, struct MovieTrackingObject *object);
-struct MovieTrackingObject *BKE_tracking_named_object(struct MovieTracking *tracking, const char *name);
-
-/* Select */
-void BKE_tracking_select_track(struct ListBase *tracksbase, struct MovieTrackingTrack *track, int area, int extend);
-void BKE_tracking_deselect_track(struct MovieTrackingTrack *track, int area);
+/* **** 2D stabilization **** */
+void BKE_tracking_stabilization_data_get(struct MovieTracking *tracking, int framenr, int width, int height,
+                                         float loc[2], float *scale, float *angle);
+struct ImBuf *BKE_tracking_stabilize_frame(struct MovieTracking *tracking, int framenr, struct ImBuf *ibuf,
+                                           float loc[2], float *scale, float *angle);
+void BKE_tracking_stabilization_data_to_mat4(int width, int height, float aspect, float loc[2],
+                                             float scale, float angle, float mat[4][4]);
 
 /* Dopesheet */
 void BKE_tracking_dopesheet_tag_update(struct MovieTracking *tracking);
diff --git a/source/blender/blenkernel/intern/constraint.c b/source/blender/blenkernel/intern/constraint.c
index 9bb0980ad5c..c12e740958c 100644
--- a/source/blender/blenkernel/intern/constraint.c
+++ b/source/blender/blenkernel/intern/constraint.c
@@ -3917,14 +3917,14 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
 	tracking = &clip->tracking;
 
 	if (data->object[0])
-		tracking_object = BKE_tracking_named_object(tracking, data->object);
+		tracking_object = BKE_tracking_object_get_named(tracking, data->object);
 	else
-		tracking_object = BKE_tracking_get_camera_object(tracking);
+		tracking_object = BKE_tracking_object_get_camera(tracking);
 
 	if (!tracking_object)
 		return;
 
-	track = BKE_tracking_named_track(tracking, tracking_object, data->track);
+	track = BKE_tracking_track_get_named(tracking, tracking_object, data->track);
 
 	if (!track)
 		return;
@@ -3942,14 +3942,14 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
 
 				copy_m4_m4(mat, camob->obmat);
 
-				BKE_tracking_get_interpolated_camera(tracking, tracking_object, framenr, imat);
+				BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, imat);
 				invert_m4(imat);
 
 				mul_serie_m4(cob->matrix, obmat, mat, imat, NULL, NULL, NULL, NULL, NULL);
 				translate_m4(cob->matrix, track->bundle_pos[0], track->bundle_pos[1], track->bundle_pos[2]);
 			}
 			else {
-				BKE_get_tracking_mat(cob->scene, camob, mat);
+				BKE_tracking_get_camera_object_matrix(cob->scene, camob, mat);
 
 				mult_m4_m4m4(cob->matrix, obmat, mat);
 				translate_m4(cob->matrix, track->bundle_pos[0], track->bundle_pos[1], track->bundle_pos[2]);
@@ -3981,7 +3981,7 @@ static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
 			CameraParams params;
 			float pos[2], rmat[4][4];
 
-			marker = BKE_tracking_get_marker(track, framenr);
+			marker = BKE_tracking_marker_get(track, framenr);
 
 			add_v2_v2v2(pos, marker->pos, track->offset);
 
@@ -4103,10 +4103,10 @@ static void camerasolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
 	if (clip) {
 		float mat[4][4], obmat[4][4];
 		MovieTracking *tracking = &clip->tracking;
-		MovieTrackingObject *object = BKE_tracking_get_camera_object(tracking);
+		MovieTrackingObject *object = BKE_tracking_object_get_camera(tracking);
 		int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, scene->r.cfra);
 
-		BKE_tracking_get_interpolated_camera(tracking, object, framenr, mat);
+		BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
 
 		copy_m4_m4(obmat, cob->matrix);
 
@@ -4165,7 +4165,7 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
 		MovieTracking *tracking = &clip->tracking;
 		MovieTrackingObject *object;
 
-		object = BKE_tracking_named_object(tracking, data->object);
+		object = BKE_tracking_object_get_named(tracking, data->object);
 
 		if (object) {
 			float mat[4][4], obmat[4][4], imat[4][4], cammat[4][4], camimat[4][4], parmat[4][4];
@@ -4173,7 +4173,7 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
 
 			BKE_object_where_is_calc_mat4(scene, camob, cammat);
 
-			BKE_tracking_get_interpolated_camera(tracking, object, framenr, mat);
+			BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
 
 			invert_m4_m4(camimat, cammat);
 			mult_m4_m4m4(parmat, cammat, data->invmat);
diff --git a/source/blender/blenkernel/intern/mask.c b/source/blender/blenkernel/intern/mask.c
index 7e9f189ae01..48db916b4ba 100644
--- a/source/blender/blenkernel/intern/mask.c
+++ b/source/blender/blenkernel/intern/mask.c
@@ -1156,16 +1156,16 @@ static int BKE_mask_evaluate_parent(MaskParent *parent, float ctime, float r_co[
 		if (parent->id) {
 			MovieClip *clip = (MovieClip *) parent->id;
 			MovieTracking *tracking = (MovieTracking *) &clip->tracking;
-			MovieTrackingObject *ob = BKE_tracking_named_object(tracking, parent->parent);
+			MovieTrackingObject *ob = BKE_tracking_object_get_named(tracking, parent->parent);
 
 			if (ob) {
-				MovieTrackingTrack *track = BKE_tracking_named_track(tracking, ob, parent->sub_parent);
+				MovieTrackingTrack *track = BKE_tracking_track_get_named(tracking, ob, parent->sub_parent);
 
 				MovieClipUser user = {0};
 				user.framenr = ctime;
 
 				if (track) {
-					MovieTrackingMarker *marker = BKE_tracking_get_marker(track, ctime);
+					MovieTrackingMarker *marker = BKE_tracking_marker_get(track, ctime);
 					float marker_pos_ofs[2];
 					add_v2_v2v2(marker_pos_ofs, marker->pos, track->offset);
 					BKE_mask_coord_from_movieclip(clip, &user, r_co, marker_pos_ofs);
diff --git a/source/blender/blenkernel/intern/movieclip.c b/source/blender/blenkernel/intern/movieclip.c
index adf1a2fd9a8..52c9ec4cb59 100644
--- a/source/blender/blenkernel/intern/movieclip.c
+++ b/source/blender/blenkernel/intern/movieclip.c
@@ -436,7 +436,7 @@ static MovieClip *movieclip_alloc(const char *name)
 
 	clip->aspx = clip->aspy = 1.0f;
 
-	BKE_tracking_init_settings(&clip->tracking);
+	BKE_tracking_settings_init(&clip->tracking);
 
 	clip->proxy.build_size_flag = IMB_PROXY_25;
 	clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN |
@@ -548,7 +548,7 @@ static ImBuf *get_undistorted_ibuf(MovieClip *clip, struct MovieDistortion *dist
 	if (distortion)
 		undistibuf = BKE_tracking_distortion_exec(distortion, &clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f, 1);
 	else
-		undistibuf = BKE_tracking_undistort(&clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f);
+		undistibuf = BKE_tracking_undistort_frame(&clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f);
 
 	if (undistibuf->userflags & IB_RECT_INVALID) {
 		ibuf->userflags &= ~IB_RECT_INVALID;
@@ -678,7 +678,7 @@ static ImBuf *put_postprocessed_frame_to_cache(MovieClip *clip, MovieClipUser *u
 			postproc_ibuf = IMB_dupImBuf(ibuf);
 
 		if (disable_red || disable_green || disable_blue || grayscale)
-			BKE_tracking_disable_imbuf_channels(postproc_ibuf, disable_red, disable_green, disable_blue, 1);
+			BKE_tracking_disable_channels(postproc_ibuf, disable_red, disable_green, disable_blue, 1);
 	}
 
 	IMB_refImBuf(postproc_ibuf);
@@ -799,7 +799,7 @@ static ImBuf *get_stable_cached_frame(MovieClip *clip, MovieClipUser *user, int
 
 	stableibuf = cache->stabilized.ibuf;
 
-	BKE_tracking_stabilization_data(&clip->tracking, framenr, stableibuf->x, stableibuf->y, tloc, &tscale, &tangle);
+	BKE_tracking_stabilization_data_get(&clip->tracking, framenr, stableibuf->x, stableibuf->y, tloc, &tscale, &tangle);
 
 	/* check for stabilization parameters */
 	if (tscale != cache->stabilized.scale ||
@@ -825,7 +825,7 @@ static ImBuf *put_stabilized_frame_to_cache(MovieClip *clip, MovieClipUser *user
 	if (cache->stabilized.ibuf)
 		IMB_freeImBuf(cache->stabilized.ibuf);
 
-	stableibuf = BKE_tracking_stabilize(&clip->tracking, framenr, ibuf, tloc, &tscale, &tangle);
+	stableibuf = BKE_tracking_stabilize_frame(&clip->tracking, framenr, ibuf, tloc, &tscale, &tangle);
 
 	cache->stabilized.ibuf = stableibuf;
 
@@ -1043,12 +1043,12 @@ void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClip
 	scopes->track_locked = TRUE;
 
 	if (clip) {
-		MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
+		MovieTrackingTrack *act_track = BKE_tracking_track_get_active(&clip->tracking);
 
 		if (act_track) {
 			MovieTrackingTrack *track = act_track;
 			int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
-			MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
+			MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
 
 			if (marker->flag & MARKER_DISABLED) {
 				scopes->track_disabled = TRUE;
@@ -1073,7 +1073,7 @@ void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClip
 						undist_marker.pos[0] *= width;
 						undist_marker.pos[1] *= height * aspy;
 
-						BKE_tracking_invert_intrinsics(&clip->tracking, undist_marker.pos, undist_marker.pos);
+						BKE_tracking_undistort_v2(&clip->tracking, undist_marker.pos, undist_marker.pos);
 
 						undist_marker.pos[0] /= width;
 						undist_marker.pos[1] /= height * aspy;
diff --git a/source/blender/blenkernel/intern/tracking.c b/source/blender/blenkernel/intern/tracking.c
index 0aa0d36c537..43fe94d625b 100644
--- a/source/blender/blenkernel/intern/tracking.c
+++ b/source/blender/blenkernel/intern/tracking.c
@@ -76,7 +76,191 @@ static struct {
 	ListBase tracks;
 } tracking_clipboard;
 
-/*********************** space transformation functions  *************************/
+/*********************** Common functions  *************************/
+
+static MovieTrackingTrack *tracking_track_duplicate(MovieTrackingTrack *track)
+{
+	MovieTrackingTrack *new_track;
+
+	new_track = MEM_callocN(sizeof(MovieTrackingTrack), "tracksMapMerge new_track");
+
+	*new_track = *track;
+	new_track->next = new_track->prev = NULL;
+
+	new_track->markers = MEM_dupallocN(new_track->markers);
+
+	return new_track;
+}
+
+static void tracking_tracks_free(ListBase *tracks)
+{
+	MovieTrackingTrack *track;
+
+	for (track = tracks->first; track; track = track->next) {
+		BKE_tracking_track_free(track);
+	}
+
+	BLI_freelistN(tracks);
+}
+
+static void tracking_reconstruction_free(MovieTrackingReconstruction *reconstruction)
+{
+	if (reconstruction->cameras)
+		MEM_freeN(reconstruction->cameras);
+}
+
+static void tracking_object_free(MovieTrackingObject *object)
+{
+	tracking_tracks_free(&object->tracks);
+	tracking_reconstruction_free(&object->reconstruction);
+}
+
+static void tracking_objects_free(ListBase *objects)
+{
+	MovieTrackingObject *object;
+
+	for (object = objects->first; object; object = object->next)
+		tracking_object_free(object);
+
+	BLI_freelistN(objects);
+}
+
+static void tracking_dopesheet_free(MovieTrackingDopesheet *dopesheet)
+{
+	MovieTrackingDopesheetChannel *channel;
+
+	channel = dopesheet->channels.first;
+	while (channel) {
+		if (channel->segments) {
+			MEM_freeN(channel->segments);
+		}
+
+		channel = channel->next;
+	}
+
+	BLI_freelistN(&dopesheet->channels);
+
+	dopesheet->channels.first = dopesheet->channels.last = NULL;
+	dopesheet->tot_channel = 0;
+}
+
+void BKE_tracking_free(MovieTracking *tracking)
+{
+	tracking_tracks_free(&tracking->tracks);
+	tracking_reconstruction_free(&tracking->reconstruction);
+	tracking_objects_free(&tracking->objects);
+
+	if (tracking->stabilization.scaleibuf)
+		IMB_freeImBuf(tracking->stabilization.scaleibuf);
+
+	if (tracking->camera.intrinsics)
+		BKE_tracking_distortion_free(tracking->camera.intrinsics);
+
+	tracking_dopesheet_free(&tracking->dopesheet);
+}
+
+void BKE_tracking_settings_init(MovieTracking *tracking)
+{
+	tracking->camera.sensor_width = 35.0f;
+	tracking->camera.pixel_aspect = 1.0f;
+	tracking->camera.units = CAMERA_UNITS_MM;
+
+	tracking->settings.default_motion_model = TRACK_MOTION_MODEL_TRANSLATION;
+	tracking->settings.default_minimum_correlation = 0.75;
+	tracking->settings.default_pattern_size = 11;
+	tracking->settings.default_search_size = 61;
+	tracking->settings.keyframe1 = 1;
+	tracking->settings.keyframe2 = 30;
+	tracking->settings.dist = 1;
+	tracking->settings.object_distance = 1;
+
+	tracking->stabilization.scaleinf = 1.0f;
+	tracking->stabilization.locinf = 1.0f;
+	tracking->stabilization.rotinf = 1.0f;
+	tracking->stabilization.maxscale = 2.0f;
+
+	BKE_tracking_object_add(tracking, "Camera");
+}
+
+ListBase *BKE_tracking_get_active_tracks(MovieTracking *tracking)
+{
+	MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+
+	if (object && (object->flag & TRACKING_OBJECT_CAMERA) == 0) {
+		return &object->tracks;
+	}
+
+	return &tracking->tracks;
+}
+
+MovieTrackingReconstruction *BKE_tracking_get_active_reconstruction(MovieTracking *tracking)
+{
+	MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+
+	return BKE_tracking_object_get_reconstruction(tracking, object);
+}
+
+void BKE_tracking_get_camera_object_matrix(Scene *scene, Object *ob, float mat[4][4])
+{
+	if (!ob) {
+		if (scene->camera)
+			ob = scene->camera;
+		else
+			ob = BKE_scene_camera_find(scene);
+	}
+
+	if (ob)
+		BKE_object_where_is_calc_mat4(scene, ob, mat);
+	else
+		unit_m4(mat);
+}
+
+void BKE_tracking_get_projection_matrix(MovieTracking *tracking, MovieTrackingObject *object,
+                                    int framenr, int winx, int winy, float mat[4][4])
+{
+	MovieReconstructedCamera *camera;
+	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;
+	float shiftx, shifty, winside = MAX2(winx, winy);
+
+	BKE_tracking_camera_shift_get(tracking, winx, winy, &shiftx, &shifty);
+
+	clipsta = 0.1f;
+	clipend = 1000.0f;
+
+	if (winx >= winy)
+		viewfac = (lens * winx) / tracking->camera.sensor_width;
+	else
+		viewfac = (ycor * lens * winy) / tracking->camera.sensor_width;
+
+	pixsize = clipsta / viewfac;
+
+	left = -0.5f * (float)winx + shiftx * winside;
+	bottom = -0.5f * (ycor) * (float)winy + shifty * winside;
+	right =  0.5f * (float)winx + shiftx * winside;
+	top =  0.5f * (ycor) * (float)winy + shifty * winside;
+
+	left *= pixsize;
+	right *= pixsize;
+	bottom *= pixsize;
+	top *= pixsize;
+
+	perspective_m4(winmat, left, right, bottom, top, clipsta, clipend);
+
+	camera = BKE_tracking_camera_get_reconstructed(tracking, object, framenr);
+
+	if (camera) {
+		float imat[4][4];
+
+		invert_m4_m4(imat, camera->mat);
+		mult_m4_m4m4(mat, winmat, imat);
+	}
+	else copy_m4_m4(mat, winmat);
+}
+
+/* **** space transformation functions  **** */
 
 /* Three coordinate frames: Frame, Search, and Marker
  * Two units: Pixels, Unified
@@ -100,7 +284,8 @@ static void marker_to_frame_unified(const MovieTrackingMarker *marker, const flo
 
 static void marker_unified_to_frame_pixel_coordinates(int frame_width, int frame_height,
                                                       const MovieTrackingMarker *marker,
-                                                      const float marker_unified_coords[2], float frame_pixel_coords[2])
+                                                      const float marker_unified_coords[2],
+                                                      float frame_pixel_coords[2])
 {
 	marker_to_frame_unified(marker, marker_unified_coords, frame_pixel_coords);
 	unified_to_pixel(frame_width, frame_height, frame_pixel_coords, frame_pixel_coords);
@@ -168,6 +353,7 @@ static void get_marker_coords_for_tracking(int frame_width, int frame_height,
 		search_pixel_x[i] = pixel_coords[0];
 		search_pixel_y[i] = pixel_coords[1];
 	}
+
 	/* Convert the center position (aka "pos"); this is the origin */
 	unified_coords[0] = 0.0;
 	unified_coords[1] = 0.0;
@@ -211,121 +397,81 @@ static void set_marker_coords_from_tracking(int frame_width, int frame_height, M
 }
 #endif
 
-/*********************** common functions *************************/
+/*********************** clipboard *************************/
 
-void BKE_tracking_init_settings(MovieTracking *tracking)
+void BKE_tracking_clipboard_free(void)
 {
-	tracking->camera.sensor_width = 35.0f;
-	tracking->camera.pixel_aspect = 1.0f;
-	tracking->camera.units = CAMERA_UNITS_MM;
+	MovieTrackingTrack *track = tracking_clipboard.tracks.first, *next_track;
 
-	tracking->settings.default_motion_model = TRACK_MOTION_MODEL_TRANSLATION;
-	tracking->settings.default_minimum_correlation = 0.75;
-	tracking->settings.default_pattern_size = 11;
-	tracking->settings.default_search_size = 61;
-	tracking->settings.keyframe1 = 1;
-	tracking->settings.keyframe2 = 30;
-	tracking->settings.dist = 1;
-	tracking->settings.object_distance = 1;
+	while (track) {
+		next_track = track->next;
 
-	tracking->stabilization.scaleinf = 1.0f;
-	tracking->stabilization.locinf = 1.0f;
-	tracking->stabilization.rotinf = 1.0f;
-	tracking->stabilization.maxscale = 2.0f;
+		BKE_tracking_track_free(track);
+		MEM_freeN(track);
 
-	BKE_tracking_new_object(tracking, "Camera");
+		track = next_track;
+	}
 }
 
-void BKE_tracking_clamp_marker(MovieTrackingMarker *marker, int event)
+void BKE_tracking_clipboard_copy_tracks(MovieTracking *tracking, MovieTrackingObject *object)
 {
-	int a;
-	float pat_min[2], pat_max[2];
+	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
+	MovieTrackingTrack *track = tracksbase->first;
 
-	BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
+	BKE_tracking_clipboard_free();
 
-	if (event == CLAMP_PAT_DIM) {
-		for (a = 0; a < 2; a++) {
-			/* search shouldn't be resized smaller than pattern */
-			marker->search_min[a] = MIN2(pat_min[a], marker->search_min[a]);
-			marker->search_max[a] = MAX2(pat_max[a], marker->search_max[a]);
+	while (track) {
+		if (TRACK_SELECTED(track) && (track->flag & TRACK_HIDDEN) == 0) {
+			MovieTrackingTrack *new_track = tracking_track_duplicate(track);
+
+			BLI_addtail(&tracking_clipboard.tracks, new_track);
 		}
+
+		track = track->next;
 	}
-	else if (event == CLAMP_PAT_POS) {
-		float dim[2];
+}
 
-		sub_v2_v2v2(dim, pat_max, pat_min);
+int BKE_tracking_clipboard_has_tracks(void)
+{
+	return tracking_clipboard.tracks.first != NULL;
+}
 
-		for (a = 0; a < 2; a++) {
-			int b;
-			/* pattern shouldn't be moved outside of search */
-			if (pat_min[a] < marker->search_min[a]) {
-				for (b = 0; b < 4; b++)
-					marker->pattern_corners[b][a] += marker->search_min[a] - pat_min[a];
-			}
-			if (pat_max[a] > marker->search_max[a]) {
-				for (b = 0; b < 4; b++)
-					marker->pattern_corners[b][a] -= pat_max[a] - marker->search_max[a];
-			}
-		}
-	}
-	else if (event == CLAMP_SEARCH_DIM) {
-		for (a = 0; a < 2; a++) {
-			/* search shouldn't be resized smaller than pattern */
-			marker->search_min[a] = MIN2(pat_min[a], marker->search_min[a]);
-			marker->search_max[a] = MAX2(pat_max[a], marker->search_max[a]);
-		}
-	}
-	else if (event == CLAMP_SEARCH_POS) {
-		float dim[2];
+void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingObject *object)
+{
+	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
+	MovieTrackingTrack *track = tracking_clipboard.tracks.first;
 
-		sub_v2_v2v2(dim, marker->search_max, marker->search_min);
+	while (track) {
+		MovieTrackingTrack *new_track = tracking_track_duplicate(track);
 
-		for (a = 0; a < 2; a++) {
-			/* search shouldn't be moved inside pattern */
-			if (marker->search_min[a] > pat_min[a]) {
-				marker->search_min[a] = pat_min[a];
-				marker->search_max[a] = marker->search_min[a] + dim[a];
-			}
-			if (marker->search_max[a] < pat_max[a]) {
-				marker->search_max[a] = pat_max[a];
-				marker->search_min[a] = marker->search_max[a] - dim[a];
-			}
-		}
-	}
-	else if (event == CLAMP_SEARCH_DIM) {
-		float dim[2];
-		sub_v2_v2v2(dim, pat_max, pat_min);
-		for (a = 0; a < 2; a++) {
-			marker->search_min[a] = pat_min[a];
-			marker->search_max[a] = pat_max[a];
-		}
+		BLI_addtail(tracksbase, new_track);
+		BKE_tracking_track_unique_name(tracksbase, new_track);
+
+		track = track->next;
 	}
 }
 
-void BKE_tracking_track_flag(MovieTrackingTrack *track, int area, int flag, int clear)
+/*********************** Tracks  *************************/
+
+static void tracking_marker_insert_disabled(MovieTrackingTrack *track, MovieTrackingMarker *ref_marker,
+                                            int before, int overwrite)
 {
-	if (area == TRACK_AREA_NONE)
-		return;
+	MovieTrackingMarker marker_new;
 
-	if (clear) {
-		if (area & TRACK_AREA_POINT)
-			track->flag &= ~flag;
-		if (area & TRACK_AREA_PAT)
-			track->pat_flag &= ~flag;
-		if (area & TRACK_AREA_SEARCH)
-			track->search_flag &= ~flag;
-	}
-	else {
-		if (area & TRACK_AREA_POINT)
-			track->flag |= flag;
-		if (area & TRACK_AREA_PAT)
-			track->pat_flag |= flag;
-		if (area & TRACK_AREA_SEARCH)
-			track->search_flag |= flag;
-	}
+	marker_new = *ref_marker;
+	marker_new.flag &= ~MARKER_TRACKED;
+	marker_new.flag |= MARKER_DISABLED;
+
+	if (before)
+		marker_new.framenr--;
+	else
+		marker_new.framenr++;
+
+	if (overwrite || !BKE_tracking_track_has_marker_at_frame(track, marker_new.framenr))
+		BKE_tracking_marker_insert(track, &marker_new);
 }
 
-MovieTrackingTrack *BKE_tracking_add_track(MovieTracking *tracking, ListBase *tracksbase, float x, float y,
+MovieTrackingTrack *BKE_tracking_track_add(MovieTracking *tracking, ListBase *tracksbase, float x, float y,
                                            int framenr, int width, int height)
 {
 	MovieTrackingTrack *track;
@@ -345,6 +491,7 @@ MovieTrackingTrack *BKE_tracking_add_track(MovieTracking *tracking, ListBase *tr
 	track = MEM_callocN(sizeof(MovieTrackingTrack), "add_marker_exec track");
 	strcpy(track->name, "Track");
 
+	/* fill track's settings from default settings */
 	track->motion_model = settings->default_motion_model;
 	track->minimum_correlation = settings->default_minimum_correlation;
 	track->margin = settings->default_margin;
@@ -370,22 +517,415 @@ MovieTrackingTrack *BKE_tracking_add_track(MovieTracking *tracking, ListBase *tr
 	copy_v2_v2(marker.search_max, search);
 	negate_v2_v2(marker.search_min, search);
 
-	BKE_tracking_insert_marker(track, &marker);
+	BKE_tracking_marker_insert(track, &marker);
 
 	BLI_addtail(tracksbase, track);
-	BKE_track_unique_name(tracksbase, track);
+	BKE_tracking_track_unique_name(tracksbase, track);
 
 	return track;
 }
 
-MovieTrackingMarker *BKE_tracking_insert_marker(MovieTrackingTrack *track, MovieTrackingMarker *marker)
+void BKE_tracking_track_unique_name(ListBase *tracksbase, MovieTrackingTrack *track)
+{
+	BLI_uniquename(tracksbase, track, "Track", '.', offsetof(MovieTrackingTrack, name), sizeof(track->name));
+}
+
+void BKE_tracking_track_free(MovieTrackingTrack *track)
+{
+	if (track->markers)
+		MEM_freeN(track->markers);
+}
+
+void BKE_tracking_track_flag_set(MovieTrackingTrack *track, int area, int flag)
+{
+	if (area == TRACK_AREA_NONE)
+		return;
+
+	if (area & TRACK_AREA_POINT)
+		track->flag |= flag;
+	if (area & TRACK_AREA_PAT)
+		track->pat_flag |= flag;
+	if (area & TRACK_AREA_SEARCH)
+		track->search_flag |= flag;
+}
+
+void BKE_tracking_track_flag_clear(MovieTrackingTrack *track, int area, int flag)
+{
+	if (area == TRACK_AREA_NONE)
+		return;
+
+	if (area & TRACK_AREA_POINT)
+		track->flag &= ~flag;
+	if (area & TRACK_AREA_PAT)
+		track->pat_flag &= ~flag;
+	if (area & TRACK_AREA_SEARCH)
+		track->search_flag &= ~flag;
+}
+
+int BKE_tracking_track_has_marker_at_frame(MovieTrackingTrack *track, int framenr)
+{
+	return BKE_tracking_marker_get_exact(track, framenr) != 0;
+}
+
+int BKE_tracking_track_has_enabled_marker_at_frame(MovieTrackingTrack *track, int framenr)
+{
+	MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(track, framenr);
+
+	return marker && (marker->flag & MARKER_DISABLED) == 0;
+}
+
+void BKE_tracking_track_path_clear(MovieTrackingTrack *track, int ref_frame, int action)
+{
+	int a;
+
+	if (action == TRACK_CLEAR_REMAINED) {
+		a = 1;
+
+		while (a < track->markersnr) {
+			if (track->markers[a].framenr > ref_frame) {
+				track->markersnr = a;
+				track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker) * track->markersnr);
+
+				break;
+			}
+
+			a++;
+		}
+
+		if (track->markersnr)
+			tracking_marker_insert_disabled(track, &track->markers[track->markersnr - 1], FALSE, TRUE);
+	}
+	else if (action == TRACK_CLEAR_UPTO) {
+		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));
+
+				track->markersnr = track->markersnr - a;
+				track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker) * track->markersnr);
+
+				break;
+			}
+
+			a--;
+		}
+
+		if (track->markersnr)
+			tracking_marker_insert_disabled(track, &track->markers[0], TRUE, TRUE);
+	}
+	else if (action == TRACK_CLEAR_ALL) {
+		MovieTrackingMarker *marker, marker_new;
+
+		marker = BKE_tracking_marker_get(track, ref_frame);
+		marker_new = *marker;
+
+		MEM_freeN(track->markers);
+		track->markers = NULL;
+		track->markersnr = 0;
+
+		BKE_tracking_marker_insert(track, &marker_new);
+
+		tracking_marker_insert_disabled(track, &marker_new, TRUE, TRUE);
+		tracking_marker_insert_disabled(track, &marker_new, FALSE, TRUE);
+	}
+}
+
+void BKE_tracking_tracks_join(MovieTrackingTrack *dst_track, MovieTrackingTrack *src_track)
+{
+	int i = 0, a = 0, b = 0, tot;
+	MovieTrackingMarker *markers;
+
+	tot = dst_track->markersnr + src_track->markersnr;
+	markers = MEM_callocN(tot * sizeof(MovieTrackingMarker), "tmp tracking joined tracks");
+
+	while (a < src_track->markersnr || b < dst_track->markersnr) {
+		if (b >= dst_track->markersnr) {
+			markers[i] = src_track->markers[a++];
+		}
+		else if (a >= src_track->markersnr) {
+			markers[i] = dst_track->markers[b++];
+		}
+		else if (src_track->markers[a].framenr < dst_track->markers[b].framenr) {
+			markers[i] = src_track->markers[a++];
+		}
+		else if (src_track->markers[a].framenr > dst_track->markers[b].framenr) {
+			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) {
+					/* 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
+					 */
+
+					MovieTrackingMarker *marker_a, *marker_b;
+					int start_a = a, start_b = b, len = 0, frame = src_track->markers[a].framenr;
+					int j, inverse = 0;
+
+					inverse = (b == 0) ||
+					          (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) {
+						marker_a = &src_track->markers[a];
+						marker_b = &dst_track->markers[b];
+
+						if (marker_a->flag & MARKER_DISABLED || marker_b->flag & MARKER_DISABLED)
+							break;
+
+						if (marker_a->framenr != frame || marker_b->framenr != frame)
+							break;
+
+						frame++;
+						len++;
+						a++;
+						b++;
+					}
+
+					a = start_a;
+					b = start_b;
+
+					/* linear interpolation for intersecting frames */
+					for (j = 0; j < len; j++) {
+						float fac = 0.5f;
+
+						if (len > 1)
+							fac = 1.0f / (len - 1) * j;
+
+						if (inverse)
+							fac = 1.0f - fac;
+
+						marker_a = &src_track->markers[a];
+						marker_b = &dst_track->markers[b];
+
+						markers[i] = dst_track->markers[b];
+						interp_v2_v2v2(markers[i].pos, marker_b->pos, marker_a->pos, fac);
+						a++;
+						b++;
+						i++;
+					}
+
+					/* this values will be incremented at the end of the loop cycle */
+					a--; b--; i--;
+				}
+				else {
+					markers[i] = src_track->markers[a];
+				}
+			}
+			else {
+				markers[i] = dst_track->markers[b];
+			}
+
+			a++;
+			b++;
+		}
+
+		i++;
+	}
+
+	MEM_freeN(dst_track->markers);
+
+	dst_track->markers = MEM_callocN(i * sizeof(MovieTrackingMarker), "tracking joined tracks");
+	memcpy(dst_track->markers, markers, i * sizeof(MovieTrackingMarker));
+
+	dst_track->markersnr = i;
+
+	MEM_freeN(markers);
+}
+
+MovieTrackingTrack *BKE_tracking_track_get_named(MovieTracking *tracking, MovieTrackingObject *object, const char *name)
+{
+	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
+	MovieTrackingTrack *track = tracksbase->first;
+
+	while (track) {
+		if (!strcmp(track->name, name))
+			return track;
+
+		track = track->next;
+	}
+
+	return NULL;
+}
+
+MovieTrackingTrack *BKE_tracking_track_get_indexed(MovieTracking *tracking, int tracknr, ListBase **tracksbase_r)
+{
+	MovieTrackingObject *object;
+	int cur = 1;
+
+	object = tracking->objects.first;
+	while (object) {
+		ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
+		MovieTrackingTrack *track = tracksbase->first;
+
+		while (track) {
+			if (track->flag & TRACK_HAS_BUNDLE) {
+				if (cur == tracknr) {
+					*tracksbase_r = tracksbase;
+					return track;
+				}
+
+				cur++;
+			}
+
+			track = track->next;
+		}
+
+		object = object->next;
+	}
+
+	*tracksbase_r = NULL;
+
+	return NULL;
+}
+
+MovieTrackingTrack *BKE_tracking_track_get_active(MovieTracking *tracking)
+{
+	ListBase *tracksbase;
+
+	if (!tracking->act_track)
+		return NULL;
+
+	tracksbase = BKE_tracking_get_active_tracks(tracking);
+
+	/* check that active track is in current tracks list */
+	if (BLI_findindex(tracksbase, tracking->act_track) >= 0)
+		return tracking->act_track;
+
+	return NULL;
+}
+
+static bGPDlayer *track_mask_gpencil_layer_get(MovieTrackingTrack *track)
+{
+	bGPDlayer *layer;
+
+	if (!track->gpd)
+		return NULL;
+
+	layer = track->gpd->layers.first;
+
+	while (layer) {
+		if (layer->flag & GP_LAYER_ACTIVE) {
+			bGPDframe *frame = layer->frames.first;
+			int ok = FALSE;
+
+			while (frame) {
+				if (frame->strokes.first) {
+					ok = TRUE;
+				}
+
+				frame = frame->next;
+			}
+
+			if (ok)
+				return layer;
+		}
+
+		layer = layer->next;
+	}
+
+	return NULL;
+}
+
+static void track_mask_gpencil_layer_rasterize(int frame_width, int frame_height,
+											   MovieTrackingMarker *marker, bGPDlayer *layer,
+                                               float *mask, int mask_width, int mask_height)
+{
+	bGPDframe *frame = layer->frames.first;
+
+	while (frame) {
+		bGPDstroke *stroke = frame->strokes.first;
+
+		while (stroke) {
+			bGPDspoint *stroke_points = stroke->points;
+			float *mask_points, *fp;
+			int i;
+
+			if (stroke->flag & GP_STROKE_2DSPACE) {
+				fp = mask_points = MEM_callocN(2 * stroke->totpoints * sizeof(float),
+				                               "track mask rasterization points");
+
+				for (i = 0; i < stroke->totpoints; i++, fp += 2) {
+					fp[0] = (stroke_points[i].x - marker->search_min[0]) * frame_width / mask_width;
+					fp[1] = (stroke_points[i].y - marker->search_min[1]) * frame_height / mask_height;
+				}
+
+				PLX_raskterize((float (*)[2])mask_points, stroke->totpoints, mask, mask_width, mask_height, FALSE /* XXX- TODO: make on/off for AA*/);
+
+				MEM_freeN(mask_points);
+			}
+
+			stroke = stroke->next;
+		}
+
+		frame = frame->next;
+	}
+}
+
+float *BKE_tracking_track_get_mask(int frame_width, int frame_height,
+                                   MovieTrackingTrack *track, MovieTrackingMarker *marker)
+{
+	float *mask = NULL;
+	bGPDlayer *layer = track_mask_gpencil_layer_get(track);
+	int mask_width, mask_height;
+
+	mask_width = (marker->search_max[0] - marker->search_min[0]) * frame_width;
+	mask_height = (marker->search_max[1] - marker->search_min[1]) * frame_height;
+
+	if (layer) {
+		mask = MEM_callocN(mask_width * mask_height * sizeof(float), "track mask");
+
+		track_mask_gpencil_layer_rasterize(frame_width, frame_height, marker, layer,
+		                                   mask, mask_width, mask_height);
+	}
+
+	return mask;
+}
+
+/* area - which part of marker should be selected. see TRACK_AREA_* constants */
+void BKE_tracking_track_select(ListBase *tracksbase, MovieTrackingTrack *track, int area, int extend)
+{
+	if (extend) {
+		BKE_tracking_track_flag_set(track, area, SELECT);
+	}
+	else {
+		MovieTrackingTrack *cur = tracksbase->first;
+
+		while (cur) {
+			if ((cur->flag & TRACK_HIDDEN) == 0) {
+				if (cur == track) {
+					BKE_tracking_track_flag_clear(cur, TRACK_AREA_ALL, SELECT);
+					BKE_tracking_track_flag_set(cur, area, SELECT);
+				}
+				else {
+					BKE_tracking_track_flag_clear(cur, TRACK_AREA_ALL, SELECT);
+				}
+			}
+
+			cur = cur->next;
+		}
+	}
+}
+
+void BKE_tracking_track_deselect(MovieTrackingTrack *track, int area)
+{
+	BKE_tracking_track_flag_clear(track, area, SELECT);
+}
+
+/*********************** Marker  *************************/
+
+MovieTrackingMarker *BKE_tracking_marker_insert(MovieTrackingTrack *track, MovieTrackingMarker *marker)
 {
 	MovieTrackingMarker *old_marker = NULL;
 
 	if (track->markersnr)
-		old_marker = BKE_tracking_exact_marker(track, marker->framenr);
+		old_marker = BKE_tracking_marker_get_exact(track, marker->framenr);
 
 	if (old_marker) {
+		/* simply replace settings for already allocated marker */
 		*old_marker = *marker;
 
 		return old_marker;
@@ -393,6 +933,7 @@ MovieTrackingMarker *BKE_tracking_insert_marker(MovieTrackingTrack *track, Movie
 	else {
 		int a = track->markersnr;
 
+		/* find position in array where to add new marker */
 		while (a--) {
 			if (track->markers[a].framenr < marker->framenr)
 				break;
@@ -405,8 +946,11 @@ MovieTrackingMarker *BKE_tracking_insert_marker(MovieTrackingTrack *track, Movie
 		else
 			track->markers = MEM_callocN(sizeof(MovieTrackingMarker), "MovieTracking markers");
 
+		/* shift array to "free" space for new marker */
 		memmove(track->markers + a + 2, track->markers + a + 1,
 		        (track->markersnr - a - 2) * sizeof(MovieTrackingMarker));
+
+		/* put new marker */
 		track->markers[a + 1] = *marker;
 
 		track->last_marker = a + 1;
@@ -415,7 +959,7 @@ MovieTrackingMarker *BKE_tracking_insert_marker(MovieTrackingTrack *track, Movie
 	}
 }
 
-void BKE_tracking_delete_marker(MovieTrackingTrack *track, int framenr)
+void BKE_tracking_marker_delete(MovieTrackingTrack *track, int framenr)
 {
 	int a = 0;
 
@@ -440,17 +984,73 @@ void BKE_tracking_delete_marker(MovieTrackingTrack *track, int framenr)
 	}
 }
 
-void BKE_tracking_marker_pattern_minmax(const MovieTrackingMarker *marker, float min[2], float max[2])
+void BKE_tracking_marker_clamp(MovieTrackingMarker *marker, int event)
 {
-	INIT_MINMAX2(min, max);
+	int a;
+	float pat_min[2], pat_max[2];
 
-	DO_MINMAX2(marker->pattern_corners[0], min, max);
-	DO_MINMAX2(marker->pattern_corners[1], min, max);
-	DO_MINMAX2(marker->pattern_corners[2], min, max);
-	DO_MINMAX2(marker->pattern_corners[3], min, max);
+	BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
+
+	if (event == CLAMP_PAT_DIM) {
+		for (a = 0; a < 2; a++) {
+			/* search shouldn't be resized smaller than pattern */
+			marker->search_min[a] = MIN2(pat_min[a], marker->search_min[a]);
+			marker->search_max[a] = MAX2(pat_max[a], marker->search_max[a]);
+		}
+	}
+	else if (event == CLAMP_PAT_POS) {
+		float dim[2];
+
+		sub_v2_v2v2(dim, pat_max, pat_min);
+
+		for (a = 0; a < 2; a++) {
+			int b;
+			/* pattern shouldn't be moved outside of search */
+			if (pat_min[a] < marker->search_min[a]) {
+				for (b = 0; b < 4; b++)
+					marker->pattern_corners[b][a] += marker->search_min[a] - pat_min[a];
+			}
+			if (pat_max[a] > marker->search_max[a]) {
+				for (b = 0; b < 4; b++)
+					marker->pattern_corners[b][a] -= pat_max[a] - marker->search_max[a];
+			}
+		}
+	}
+	else if (event == CLAMP_SEARCH_DIM) {
+		for (a = 0; a < 2; a++) {
+			/* search shouldn't be resized smaller than pattern */
+			marker->search_min[a] = MIN2(pat_min[a], marker->search_min[a]);
+			marker->search_max[a] = MAX2(pat_max[a], marker->search_max[a]);
+		}
+	}
+	else if (event == CLAMP_SEARCH_POS) {
+		float dim[2];
+
+		sub_v2_v2v2(dim, marker->search_max, marker->search_min);
+
+		for (a = 0; a < 2; a++) {
+			/* search shouldn't be moved inside pattern */
+			if (marker->search_min[a] > pat_min[a]) {
+				marker->search_min[a] = pat_min[a];
+				marker->search_max[a] = marker->search_min[a] + dim[a];
+			}
+			if (marker->search_max[a] < pat_max[a]) {
+				marker->search_max[a] = pat_max[a];
+				marker->search_min[a] = marker->search_max[a] - dim[a];
+			}
+		}
+	}
+	else if (event == CLAMP_SEARCH_DIM) {
+		float dim[2];
+		sub_v2_v2v2(dim, pat_max, pat_min);
+		for (a = 0; a < 2; a++) {
+			marker->search_min[a] = pat_min[a];
+			marker->search_max[a] = pat_max[a];
+		}
+	}
 }
 
-MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int framenr)
+MovieTrackingMarker *BKE_tracking_marker_get(MovieTrackingTrack *track, int framenr)
 {
 	int a = track->markersnr - 1;
 
@@ -495,9 +1095,19 @@ MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int fram
 	return NULL;
 }
 
-MovieTrackingMarker *BKE_tracking_ensure_marker(MovieTrackingTrack *track, int framenr)
+MovieTrackingMarker *BKE_tracking_marker_get_exact(MovieTrackingTrack *track, int framenr)
+{
+	MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
+
+	if (marker->framenr != framenr)
+		return NULL;
+
+	return marker;
+}
+
+MovieTrackingMarker *BKE_tracking_marker_ensure(MovieTrackingTrack *track, int framenr)
 {
-	MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
+	MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
 
 	if (marker->framenr != framenr) {
 		MovieTrackingMarker marker_new;
@@ -505,352 +1115,663 @@ MovieTrackingMarker *BKE_tracking_ensure_marker(MovieTrackingTrack *track, int f
 		marker_new = *marker;
 		marker_new.framenr = framenr;
 
-		BKE_tracking_insert_marker(track, &marker_new);
-		marker = BKE_tracking_get_marker(track, framenr);
+		BKE_tracking_marker_insert(track, &marker_new);
+		marker = BKE_tracking_marker_get(track, framenr);
 	}
 
 	return marker;
 }
 
-MovieTrackingMarker *BKE_tracking_exact_marker(MovieTrackingTrack *track, int framenr)
+void BKE_tracking_marker_pattern_minmax(const MovieTrackingMarker *marker, float min[2], float max[2])
 {
-	MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
-
-	if (marker->framenr != framenr)
-		return NULL;
+	INIT_MINMAX2(min, max);
 
-	return marker;
+	DO_MINMAX2(marker->pattern_corners[0], min, max);
+	DO_MINMAX2(marker->pattern_corners[1], min, max);
+	DO_MINMAX2(marker->pattern_corners[2], min, max);
+	DO_MINMAX2(marker->pattern_corners[3], min, max);
 }
 
-int BKE_tracking_has_marker(MovieTrackingTrack *track, int framenr)
+/*********************** Object *************************/
+
+MovieTrackingObject *BKE_tracking_object_add(MovieTracking *tracking, const char *name)
 {
-	return BKE_tracking_exact_marker(track, framenr) != 0;
+	MovieTrackingObject *object = MEM_callocN(sizeof(MovieTrackingObject), "tracking object");
+
+	if (tracking->tot_object == 0) {
+		/* first object is always camera */
+		BLI_strncpy(object->name, "Camera", sizeof(object->name));
+
+		object->flag |= TRACKING_OBJECT_CAMERA;
+	}
+	else {
+		BLI_strncpy(object->name, name, sizeof(object->name));
+	}
+
+	BLI_addtail(&tracking->objects, object);
+
+	tracking->tot_object++;
+	tracking->objectnr = BLI_countlist(&tracking->objects) - 1;
+
+	object->scale = 1.0f;
+
+	BKE_tracking_object_unique_name(tracking, object);
+
+	return object;
 }
 
-int BKE_tracking_has_enabled_marker(MovieTrackingTrack *track, int framenr)
+void BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *object)
 {
-	MovieTrackingMarker *marker = BKE_tracking_exact_marker(track, framenr);
+	MovieTrackingTrack *track;
+	int index = BLI_findindex(&tracking->objects, object);
 
-	return marker && (marker->flag & MARKER_DISABLED) == 0;
+	if (index < 0)
+		return;
+
+	if (object->flag & TRACKING_OBJECT_CAMERA) {
+		/* object used for camera solving can't be deleted */
+		return;
+	}
+
+	track = object->tracks.first;
+	while (track) {
+		if (track == tracking->act_track)
+			tracking->act_track = NULL;
+
+		track = track->next;
+	}
+
+	tracking_object_free(object);
+	BLI_freelinkN(&tracking->objects, object);
+
+	tracking->tot_object--;
+
+	if (index > 0)
+		tracking->objectnr = index - 1;
+	else
+		tracking->objectnr = 0;
 }
 
-void BKE_tracking_free_track(MovieTrackingTrack *track)
+void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *object)
 {
-	if (track->markers)
-		MEM_freeN(track->markers);
+	BLI_uniquename(&tracking->objects, object, "Object", '.',
+	               offsetof(MovieTrackingObject, name), sizeof(object->name));
 }
 
-static void put_disabled_marker(MovieTrackingTrack *track, MovieTrackingMarker *ref_marker, int before, int overwrite)
+MovieTrackingObject *BKE_tracking_object_get_named(MovieTracking *tracking, const char *name)
 {
-	MovieTrackingMarker marker_new;
+	MovieTrackingObject *object = tracking->objects.first;
 
-	marker_new = *ref_marker;
-	marker_new.flag &= ~MARKER_TRACKED;
-	marker_new.flag |= MARKER_DISABLED;
+	while (object) {
+		if (!strcmp(object->name, name))
+			return object;
 
-	if (before)
-		marker_new.framenr--;
-	else
-		marker_new.framenr++;
+		object = object->next;
+	}
 
-	if (!BKE_tracking_has_marker(track, marker_new.framenr) || overwrite)
-		BKE_tracking_insert_marker(track, &marker_new);
+	return NULL;
 }
 
-void BKE_tracking_clear_path(MovieTrackingTrack *track, int ref_frame, int action)
+MovieTrackingObject *BKE_tracking_object_get_active(MovieTracking *tracking)
 {
-	int a;
+	return BLI_findlink(&tracking->objects, tracking->objectnr);
+}
 
-	if (action == TRACK_CLEAR_REMAINED) {
-		a = 1;
+MovieTrackingObject *BKE_tracking_object_get_camera(MovieTracking *tracking)
+{
+	MovieTrackingObject *object = tracking->objects.first;
 
-		while (a < track->markersnr) {
-			if (track->markers[a].framenr > ref_frame) {
-				track->markersnr = a;
-				track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker) * track->markersnr);
+	while (object) {
+		if (object->flag & TRACKING_OBJECT_CAMERA)
+			return object;
 
-				break;
-			}
+		object = object->next;
+	}
 
-			a++;
-		}
+	return NULL;
+}
 
-		if (track->markersnr)
-			put_disabled_marker(track, &track->markers[track->markersnr - 1], 0, 1);
+ListBase *BKE_tracking_object_get_tracks(MovieTracking *tracking, MovieTrackingObject *object)
+{
+	if (object->flag & TRACKING_OBJECT_CAMERA) {
+		return &tracking->tracks;
 	}
-	else if (action == TRACK_CLEAR_UPTO) {
-		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));
 
-				track->markersnr = track->markersnr - a;
-				track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker) * track->markersnr);
+	return &object->tracks;
+}
 
-				break;
-			}
+MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(MovieTracking *tracking,
+                                                                    MovieTrackingObject *object)
+{
+	if (object->flag & TRACKING_OBJECT_CAMERA) {
+		return &tracking->reconstruction;
+	}
 
-			a--;
-		}
+	return &object->reconstruction;
+}
 
-		if (track->markersnr)
-			put_disabled_marker(track, &track->markers[0], 1, 1);
-	}
-	else if (action == TRACK_CLEAR_ALL) {
-		MovieTrackingMarker *marker, marker_new;
+/*********************** Camera *************************/
 
-		marker = BKE_tracking_get_marker(track, ref_frame);
-		marker_new = *marker;
+static int reconstructed_camera_index_get(MovieTrackingReconstruction *reconstruction, int framenr, int nearest)
+{
+	MovieReconstructedCamera *cameras = reconstruction->cameras;
+	int a = 0, d = 1;
 
-		MEM_freeN(track->markers);
-		track->markers = NULL;
-		track->markersnr = 0;
+	if (!reconstruction->camnr)
+		return -1;
 
-		BKE_tracking_insert_marker(track, &marker_new);
+	if (framenr < cameras[0].framenr) {
+		if (nearest)
+			return 0;
+		else
+			return -1;
+	}
 
-		put_disabled_marker(track, &marker_new, 1, 1);
-		put_disabled_marker(track, &marker_new, 0, 1);
+	if (framenr > cameras[reconstruction->camnr - 1].framenr) {
+		if (nearest)
+			return reconstruction->camnr - 1;
+		else
+			return -1;
 	}
-}
 
-void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack *src_track)
-{
-	int i = 0, a = 0, b = 0, tot;
-	MovieTrackingMarker *markers;
+	if (reconstruction->last_camera < reconstruction->camnr)
+		a = reconstruction->last_camera;
 
-	tot = dst_track->markersnr + src_track->markersnr;
-	markers = MEM_callocN(tot * sizeof(MovieTrackingMarker), "tmp tracking joined tracks");
+	if (cameras[a].framenr >= framenr)
+		d = -1;
 
-	while (a < src_track->markersnr || b < dst_track->markersnr) {
-		if (b >= dst_track->markersnr) {
-			markers[i] = src_track->markers[a++];
-		}
-		else if (a >= src_track->markersnr) {
-			markers[i] = dst_track->markers[b++];
+	while (a >= 0 && a < reconstruction->camnr) {
+		int cfra = cameras[a].framenr;
+
+		/* check if needed framenr was "skipped" -- no data for requested frame */
+
+		if (d > 0 && cfra > framenr) {
+			/* interpolate with previous position */
+			if (nearest)
+				return a - 1;
+			else
+				break;
 		}
-		else if (src_track->markers[a].framenr < dst_track->markers[b].framenr) {
-			markers[i] = src_track->markers[a++];
+
+		if (d < 0 && cfra < framenr) {
+			/* interpolate with next position */
+			if (nearest)
+				return a;
+			else
+				break;
 		}
-		else if (src_track->markers[a].framenr > dst_track->markers[b].framenr) {
-			markers[i] = dst_track->markers[b++];
+
+		if (cfra == framenr) {
+			reconstruction->last_camera = a;
+
+			return a;
 		}
-		else {
-			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
-					 */
 
-					MovieTrackingMarker *marker_a, *marker_b;
-					int start_a = a, start_b = b, len = 0, frame = src_track->markers[a].framenr;
-					int j, inverse = 0;
+		a += d;
+	}
 
-					inverse = (b == 0) ||
-					          (dst_track->markers[b - 1].flag & MARKER_DISABLED) ||
-					          (dst_track->markers[b - 1].framenr != frame - 1);
+	return -1;
+}
 
-					/* find length of intersection */
-					while (a < src_track->markersnr && b < dst_track->markersnr) {
-						marker_a = &src_track->markers[a];
-						marker_b = &dst_track->markers[b];
+static void reconstructed_camera_scale_set(MovieTrackingObject *object, float mat[4][4])
+{
+	if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) {
+		float smat[4][4];
 
-						if (marker_a->flag & MARKER_DISABLED || marker_b->flag & MARKER_DISABLED)
-							break;
+		scale_m4_fl(smat, 1.0f / object->scale);
+		mult_m4_m4m4(mat, mat, smat);
+	}
+}
 
-						if (marker_a->framenr != frame || marker_b->framenr != frame)
-							break;
 
-						frame++;
-						len++;
-						a++;
-						b++;
-					}
+/* converts principal offset from center to offset of blender's camera */
+void BKE_tracking_camera_shift_get(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;
+}
 
-					a = start_a;
-					b = start_b;
+void BKE_tracking_camera_to_blender(MovieTracking *tracking, Scene *scene, Camera *camera, int width, int height)
+{
+	float focal = tracking->camera.focal;
 
-					/* linear interpolation for intersecting frames */
-					for (j = 0; j < len; j++) {
-						float fac = 0.5f;
+	camera->sensor_x = tracking->camera.sensor_width;
+	camera->sensor_fit = CAMERA_SENSOR_FIT_AUTO;
+	camera->lens = focal * camera->sensor_x / width;
 
-						if (len > 1)
-							fac = 1.0f / (len - 1) * j;
+	scene->r.xsch = width * tracking->camera.pixel_aspect;
+	scene->r.ysch = height;
 
-						if (inverse)
-							fac = 1.0f - fac;
+	scene->r.xasp = 1.0f;
+	scene->r.yasp = 1.0f;
 
-						marker_a = &src_track->markers[a];
-						marker_b = &dst_track->markers[b];
+	BKE_tracking_camera_shift_get(tracking, width, height, &camera->shiftx, &camera->shifty);
+}
 
-						markers[i] = dst_track->markers[b];
-						interp_v2_v2v2(markers[i].pos, marker_b->pos, marker_a->pos, fac);
-						a++;
-						b++;
-						i++;
-					}
+MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(MovieTracking *tracking,
+                                                                MovieTrackingObject *object, int framenr)
+{
+	MovieTrackingReconstruction *reconstruction;
+	int a;
 
-					/* this values will be incremented at the end of the loop cycle */
-					a--; b--; i--;
-				}
-				else markers[i] = src_track->markers[a];
-			}
-			else markers[i] = dst_track->markers[b];
+	reconstruction = BKE_tracking_object_get_reconstruction(tracking, object);
+	a = reconstructed_camera_index_get(reconstruction, framenr, FALSE);
 
-			a++;
-			b++;
-		}
+	if (a == -1)
+		return NULL;
 
-		i++;
-	}
+	return &reconstruction->cameras[a];
+}
 
-	MEM_freeN(dst_track->markers);
+void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *tracking, MovieTrackingObject *object,
+                                                       int framenr, float mat[4][4])
+{
+	MovieTrackingReconstruction *reconstruction;
+	MovieReconstructedCamera *cameras;
+	int a;
 
-	dst_track->markers = MEM_callocN(i * sizeof(MovieTrackingMarker), "tracking joined tracks");
-	memcpy(dst_track->markers, markers, i * sizeof(MovieTrackingMarker));
+	reconstruction = BKE_tracking_object_get_reconstruction(tracking, object);
+	cameras = reconstruction->cameras;
+	a = reconstructed_camera_index_get(reconstruction, framenr, 1);
 
-	dst_track->markersnr = i;
+	if (a == -1) {
+		unit_m4(mat);
 
-	MEM_freeN(markers);
-}
+		return;
+	}
 
-static void tracking_tracks_free(ListBase *tracks)
-{
-	MovieTrackingTrack *track;
+	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);
 
-	for (track = tracks->first; track; track = track->next) {
-		BKE_tracking_free_track(track);
+		blend_m4_m4m4(mat, cameras[a].mat, cameras[a + 1].mat, t);
+	}
+	else {
+		copy_m4_m4(mat, cameras[a].mat);
 	}
 
-	BLI_freelistN(tracks);
+	reconstructed_camera_scale_set(object, mat);
 }
 
-static void tracking_reconstruction_free(MovieTrackingReconstruction *reconstruction)
+/*********************** Distortion/Undistortion *************************/
+
+MovieDistortion *BKE_tracking_distortion_new(void)
 {
-	if (reconstruction->cameras)
-		MEM_freeN(reconstruction->cameras);
+	MovieDistortion *distortion;
+
+	distortion = MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
+
+	return distortion;
 }
 
-static void tracking_object_free(MovieTrackingObject *object)
+void BKE_tracking_distortion_update(MovieDistortion *distortion, MovieTracking *tracking,
+                                    int calibration_width, int calibration_height)
 {
-	tracking_tracks_free(&object->tracks);
-	tracking_reconstruction_free(&object->reconstruction);
+	MovieTrackingCamera *camera = &tracking->camera;
+	float aspy = 1.0f / tracking->camera.pixel_aspect;
+
+#ifdef WITH_LIBMV
+	if (!distortion->intrinsics) {
+		distortion->intrinsics = libmv_CameraIntrinsicsNew(camera->focal,
+		                                                   camera->principal[0], camera->principal[1] * aspy,
+		                                                   camera->k1, camera->k2, camera->k3,
+                                                           calibration_width, calibration_height * aspy);
+	}
+	else {
+		libmv_CameraIntrinsicsUpdate(distortion->intrinsics, camera->focal,
+		                             camera->principal[0], camera->principal[1] * aspy,
+		                             camera->k1, camera->k2, camera->k3,
+                                     calibration_width, calibration_height * aspy);
+	}
+#else
+	(void) distortion;
+	(void) width;
+	(void) height;
+	(void) camera;
+	(void) aspy;
+#endif
 }
 
-static void tracking_objects_free(ListBase *objects)
+MovieDistortion *BKE_tracking_distortion_copy(MovieDistortion *distortion)
 {
-	MovieTrackingObject *object;
+	MovieDistortion *new_distortion;
 
-	for (object = objects->first; object; object = object->next)
-		tracking_object_free(object);
+	new_distortion = MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
 
-	BLI_freelistN(objects);
+#ifdef WITH_LIBMV
+	new_distortion->intrinsics = libmv_CameraIntrinsicsCopy(distortion->intrinsics);
+#else
+	(void) distortion;
+#endif
+
+	return new_distortion;
 }
 
-static void tracking_dopesheet_free(MovieTrackingDopesheet *dopesheet)
+ImBuf *BKE_tracking_distortion_exec(MovieDistortion *distortion, MovieTracking *tracking, ImBuf *ibuf,
+                                    int calibration_width, int calibration_height, float overscan, int undistort)
 {
-	MovieTrackingDopesheetChannel *channel;
+	ImBuf *resibuf;
 
-	channel = dopesheet->channels.first;
-	while (channel) {
-		if (channel->segments) {
-			MEM_freeN(channel->segments);
+	BKE_tracking_distortion_update(distortion, tracking, calibration_width, calibration_height);
+
+	resibuf = IMB_dupImBuf(ibuf);
+
+#ifdef WITH_LIBMV
+	if (ibuf->rect_float) {
+		if (undistort) {
+			libmv_CameraIntrinsicsUndistortFloat(distortion->intrinsics,
+			                                     ibuf->rect_float, resibuf->rect_float,
+			                                     ibuf->x, ibuf->y, overscan, ibuf->channels);
+		}
+		else {
+			libmv_CameraIntrinsicsDistortFloat(distortion->intrinsics,
+			                                   ibuf->rect_float, resibuf->rect_float,
+			                                   ibuf->x, ibuf->y, overscan, ibuf->channels);
 		}
 
-		channel = channel->next;
+		resibuf->userflags |= IB_RECT_INVALID;
 	}
+	else {
+		if (undistort) {
+			libmv_CameraIntrinsicsUndistortByte(distortion->intrinsics,
+			                                    (unsigned char *)ibuf->rect, (unsigned char *)resibuf->rect,
+			                                    ibuf->x, ibuf->y, overscan, ibuf->channels);
+		}
+		else {
+			libmv_CameraIntrinsicsDistortByte(distortion->intrinsics,
+			                                  (unsigned char *)ibuf->rect, (unsigned char *)resibuf->rect,
+			                                  ibuf->x, ibuf->y, overscan, ibuf->channels);
+		}
+	}
+#else
+	(void) overscan;
+	(void) undistort;
 
-	BLI_freelistN(&dopesheet->channels);
+	if (ibuf->rect_float) {
+		resibuf->userflags |= IB_RECT_INVALID;
+	}
+#endif
 
-	dopesheet->channels.first = dopesheet->channels.last = NULL;
-	dopesheet->tot_channel = 0;
+	return resibuf;
 }
 
-void BKE_tracking_free(MovieTracking *tracking)
+void BKE_tracking_distortion_free(MovieDistortion *distortion)
 {
-	tracking_tracks_free(&tracking->tracks);
-	tracking_reconstruction_free(&tracking->reconstruction);
-	tracking_objects_free(&tracking->objects);
+#ifdef WITH_LIBMV
+	libmv_CameraIntrinsicsDestroy(distortion->intrinsics);
+#endif
 
-	if (tracking->stabilization.scaleibuf)
-		IMB_freeImBuf(tracking->stabilization.scaleibuf);
+	MEM_freeN(distortion);
+}
 
-	if (tracking->camera.intrinsics)
-		BKE_tracking_distortion_destroy(tracking->camera.intrinsics);
+void BKE_tracking_distort_v2(MovieTracking *tracking, float co[2], float nco[2])
+{
+	MovieTrackingCamera *camera = &tracking->camera;
 
-	tracking_dopesheet_free(&tracking->dopesheet);
+#ifdef WITH_LIBMV
+	double x, y;
+	float aspy = 1.0f / tracking->camera.pixel_aspect;
+
+	/* normalize coords */
+	x = (co[0] - camera->principal[0]) / camera->focal;
+	y = (co[1] - camera->principal[1] * aspy) / camera->focal;
+
+	libmv_applyCameraIntrinsics(camera->focal, camera->principal[0], camera->principal[1] * aspy,
+	                            camera->k1, camera->k2, camera->k3, x, y, &x, &y);
+
+	/* result is in image coords already */
+	nco[0] = x;
+	nco[1] = y;
+#else
+	(void) camera;
+	(void) co;
+	(void) nco;
+#endif
 }
 
-static MovieTrackingTrack *duplicate_track(MovieTrackingTrack *track)
+void BKE_tracking_undistort_v2(MovieTracking *tracking, float co[2], float nco[2])
 {
-	MovieTrackingTrack *new_track;
+	MovieTrackingCamera *camera = &tracking->camera;
 
-	new_track = MEM_callocN(sizeof(MovieTrackingTrack), "tracksMapMerge new_track");
+#ifdef WITH_LIBMV
+	double x = co[0], y = co[1];
+	float aspy = 1.0f / tracking->camera.pixel_aspect;
 
-	*new_track = *track;
-	new_track->next = new_track->prev = NULL;
+	libmv_InvertIntrinsics(camera->focal, camera->principal[0], camera->principal[1] * aspy,
+	                       camera->k1, camera->k2, camera->k3, x, y, &x, &y);
 
-	new_track->markers = MEM_dupallocN(new_track->markers);
+	nco[0] = x * camera->focal + camera->principal[0];
+	nco[1] = y * camera->focal + camera->principal[1] * aspy;
+#else
+	(void) camera;
+	(void) co;
+	(void) nco;
+#endif
+}
 
-	return new_track;
+ImBuf *BKE_tracking_undistort_frame(MovieTracking *tracking, ImBuf *ibuf, int calibration_width,
+                                    int calibration_height, float overscan)
+{
+	MovieTrackingCamera *camera = &tracking->camera;
+
+	if (camera->intrinsics == NULL)
+		camera->intrinsics = BKE_tracking_distortion_new();
+
+	return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, calibration_width,
+                                        calibration_height, overscan, TRUE);
 }
 
-/*********************** clipboard *************************/
+ImBuf *BKE_tracking_distort_frame(MovieTracking *tracking, ImBuf *ibuf, int calibration_width,
+                                  int calibration_height, float overscan)
+{
+	MovieTrackingCamera *camera = &tracking->camera;
+
+	if (camera->intrinsics == NULL)
+		camera->intrinsics = BKE_tracking_distortion_new();
+
+	return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, calibration_width,
+                                        calibration_height, overscan, FALSE);
+}
 
-void BKE_tracking_free_clipboard(void)
+/*********************** Image sampling *************************/
+
+static void disable_imbuf_channels(ImBuf *ibuf, MovieTrackingTrack *track, int grayscale)
 {
-	MovieTrackingTrack *track = tracking_clipboard.tracks.first, *next_track;
+	BKE_tracking_disable_channels(ibuf, track->flag & TRACK_DISABLE_RED,
+	                                    track->flag & TRACK_DISABLE_GREEN,
+                                        track->flag & TRACK_DISABLE_BLUE, grayscale);
+}
 
-	while (track) {
-		next_track = track->next;
+ImBuf *BKE_tracking_sample_pattern(int frame_width, int frame_height, ImBuf *search_ibuf,
+                                         MovieTrackingTrack *track, MovieTrackingMarker *marker,
+                                         int use_mask, int num_samples_x, int num_samples_y,
+                                         float pos[2])
+{
+#ifdef WITH_LIBMV
+	ImBuf *pattern_ibuf;
+	double src_pixel_x[5], src_pixel_y[5];
+	double warped_position_x, warped_position_y;
+	float *mask = NULL;
 
-		BKE_tracking_free_track(track);
-		MEM_freeN(track);
+	pattern_ibuf = IMB_allocImBuf(num_samples_x, num_samples_y, 32, IB_rectfloat);
+	pattern_ibuf->profile = IB_PROFILE_LINEAR_RGB;
 
-		track = next_track;
+	if (!search_ibuf->rect_float) {
+		IMB_float_from_rect(search_ibuf);
+	}
+
+	get_marker_coords_for_tracking(frame_width, frame_height, marker, src_pixel_x, src_pixel_y);
+
+	if (use_mask) {
+		mask = BKE_tracking_track_get_mask(frame_width, frame_height, track, marker);
+	}
+
+	libmv_samplePlanarPatch(search_ibuf->rect_float, search_ibuf->x, search_ibuf->y, 4,
+	                        src_pixel_x, src_pixel_y, num_samples_x,
+	                        num_samples_y, mask, pattern_ibuf->rect_float,
+	                        &warped_position_x, &warped_position_y);
+
+	if (pos) {
+		pos[0] = warped_position_x;
+		pos[1] = warped_position_y;
+	}
+
+	if (mask) {
+		MEM_freeN(mask);
 	}
+
+	return pattern_ibuf;
+#else
+	ImBuf *pattern_ibuf;
+
+	/* real sampling requires libmv, but areas are supposing pattern would be
+	 * sampled if search area does exists, so we'll need to create empty
+	 * pattern area here to prevent adding NULL-checks all over just to deal
+	 * with situation when lubmv is disabled
+	 */
+
+	(void) frame_width;
+	(void) frame_height;
+	(void) search_ibuf;
+	(void) marker;
+	(void) track;
+	(void) use_mask;
+
+	pattern_ibuf = IMB_allocImBuf(num_samples_x, num_samples_y, 32, IB_rectfloat);
+
+	pos[0] = num_samples_x / 2.0f;
+	pos[1] = num_samples_y / 2.0f;
+
+	return pattern_ibuf;
+#endif
 }
 
-void BKE_tracking_clipboard_copy_tracks(MovieTracking *tracking, MovieTrackingObject *object)
+ImBuf *BKE_tracking_get_pattern_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+                                      int anchored, int disable_channels)
 {
-	ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
-	MovieTrackingTrack *track = tracksbase->first;
+	ImBuf *pattern_ibuf, *search_ibuf;
+	float pat_min[2], pat_max[2];
+	int num_samples_x, num_samples_y;
 
-	BKE_tracking_free_clipboard();
+	BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
 
-	while (track) {
-		if (TRACK_SELECTED(track) && (track->flag & TRACK_HIDDEN) == 0) {
-			MovieTrackingTrack *new_track = duplicate_track(track);
+	num_samples_x = (pat_max[0] - pat_min[0]) * ibuf->x;
+	num_samples_y = (pat_max[1] - pat_min[1]) * ibuf->y;
 
-			BLI_addtail(&tracking_clipboard.tracks, new_track);
-		}
+	search_ibuf = BKE_tracking_get_search_imbuf(ibuf, track, marker, anchored, disable_channels);
 
-		track = track->next;
-	}
+	pattern_ibuf = BKE_tracking_sample_pattern(ibuf->x, ibuf->y, search_ibuf, track, marker,
+	                                                 FALSE, num_samples_x, num_samples_y, NULL);
+
+	IMB_freeImBuf(search_ibuf);
+
+	return pattern_ibuf;
 }
 
-int BKE_tracking_clipboard_has_tracks(void)
+ImBuf *BKE_tracking_get_search_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+                                     int anchored, int disable_channels)
 {
-	return tracking_clipboard.tracks.first != NULL;
+	ImBuf *searchibuf;
+	int x, y, w, h;
+	float search_origin[2];
+
+	get_search_origin_frame_pixel(ibuf->x, ibuf->y, marker, search_origin);
+
+	x = search_origin[0];
+	y = search_origin[1];
+
+	if (anchored) {
+		x += track->offset[0] * ibuf->x;
+		y += track->offset[1] * ibuf->y;
+	}
+
+	w = (marker->search_max[0] - marker->search_min[0]) * ibuf->x;
+	h = (marker->search_max[1] - marker->search_min[1]) * ibuf->y;
+
+	searchibuf = IMB_allocImBuf(w, h, 32, ibuf->rect_float ? IB_rectfloat : IB_rect);
+	searchibuf->profile = ibuf->profile;
+
+	IMB_rectcpy(searchibuf, ibuf, 0, 0, x, y, w, h);
+
+	if (disable_channels) {
+		if ((track->flag & TRACK_PREVIEW_GRAYSCALE) ||
+		    (track->flag & TRACK_DISABLE_RED)       ||
+		    (track->flag & TRACK_DISABLE_GREEN)     ||
+		    (track->flag & TRACK_DISABLE_BLUE))
+		{
+			disable_imbuf_channels(searchibuf, track, TRUE);
+		}
+	}
+
+	return searchibuf;
 }
 
-void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingObject *object)
+/* 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_channels(ImBuf *ibuf, int disable_red, int disable_green, int disable_blue,
+                                         int grayscale)
 {
-	ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
-	MovieTrackingTrack *track = tracking_clipboard.tracks.first;
+	int x, y;
+	float scale;
 
-	while (track) {
-		MovieTrackingTrack *new_track = duplicate_track(track);
+	if (!disable_red && !disable_green && !disable_blue && !grayscale)
+		return;
 
-		BLI_addtail(tracksbase, new_track);
-		BKE_track_unique_name(tracksbase, new_track);
+	/* if only some components are selected, it's important to rescale the result
+	 * appropriately so that e.g. if only blue is selected, it's not zeroed out.
+	 */
+	scale = (disable_red   ? 0.0f : 0.2126f) +
+	        (disable_green ? 0.0f : 0.7152f) +
+	        (disable_blue  ? 0.0f : 0.0722f);
 
-		track = track->next;
+	for (y = 0; y < ibuf->y; y++) {
+		for (x = 0; x < ibuf->x; x++) {
+			int pixel = ibuf->x * y + x;
+
+			if (ibuf->rect_float) {
+				float *rrgbf = ibuf->rect_float + pixel * 4;
+				float r = disable_red   ? 0.0f : rrgbf[0];
+				float g = disable_green ? 0.0f : rrgbf[1];
+				float b = disable_blue  ? 0.0f : rrgbf[2];
+
+				if (grayscale) {
+					float gray = (0.2126f * r + 0.7152f * g + 0.0722f * b) / scale;
+
+					rrgbf[0] = rrgbf[1] = rrgbf[2] = gray;
+				}
+				else {
+					rrgbf[0] = r;
+					rrgbf[1] = g;
+					rrgbf[2] = b;
+				}
+			}
+			else {
+				char *rrgb = (char *)ibuf->rect + pixel * 4;
+				char r = disable_red   ? 0 : rrgb[0];
+				char g = disable_green ? 0 : rrgb[1];
+				char b = disable_blue  ? 0 : rrgb[2];
+
+				if (grayscale) {
+					float gray = (0.2126f * r + 0.7152f * g + 0.0722f * b) / scale;
+
+					rrgb[0] = rrgb[1] = rrgb[2] = gray;
+				}
+				else {
+					rrgb[0] = r;
+					rrgb[1] = g;
+					rrgb[2] = b;
+				}
+			}
+		}
 	}
+
+	if (ibuf->rect_float)
+		ibuf->userflags |= IB_RECT_INVALID;
 }
 
-/*********************** tracks map *************************/
+/*********************** Tracks map *************************/
 
 typedef struct TracksMap {
 	char object_name[MAX_NAME];
@@ -887,12 +1808,12 @@ static TracksMap *tracks_map_new(const char *object_name, int is_camera, int num
 	return map;
 }
 
-static int tracks_map_size(TracksMap *map)
+static int tracks_map_get_size(TracksMap *map)
 {
 	return map->num_tracks;
 }
 
-static void tracks_map_get(TracksMap *map, int index, MovieTrackingTrack **track, void **customdata)
+static void tracks_map_get_indexed_element(TracksMap *map, int index, MovieTrackingTrack **track, void **customdata)
 {
 	*track = &map->tracks[index];
 
@@ -919,7 +1840,7 @@ static void tracks_map_insert(TracksMap *map, MovieTrackingTrack *track, void *c
 static void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
 {
 	MovieTrackingTrack *track;
-	MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
+	MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
 	MovieTrackingTrack *rot_track = tracking->stabilization.rot_track;
 	ListBase tracks = {NULL, NULL}, new_tracks = {NULL, NULL};
 	ListBase *old_tracks;
@@ -929,11 +1850,11 @@ static void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
 		old_tracks = &tracking->tracks;
 	}
 	else {
-		MovieTrackingObject *object = BKE_tracking_named_object(tracking, map->object_name);
+		MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name);
 
 		if (!object) {
 			/* object was deleted by user, create new one */
-			object = BKE_tracking_new_object(tracking, map->object_name);
+			object = BKE_tracking_object_add(tracking, map->object_name);
 		}
 
 		old_tracks = &object->tracks;
@@ -972,12 +1893,12 @@ static void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
 				track->pat_flag = cur->pat_flag;
 				track->search_flag = cur->search_flag;
 
-				BKE_tracking_free_track(cur);
+				BKE_tracking_track_free(cur);
 				BLI_freelinkN(old_tracks, cur);
 			}
 		}
 
-		new_track = duplicate_track(track);
+		new_track = tracking_track_duplicate(track);
 
 		BLI_ghash_remove(map->hash, track, NULL, NULL); /* XXX: are we actually need this */
 		BLI_ghash_insert(map->hash, track, new_track);
@@ -1030,7 +1951,7 @@ static void tracks_map_free(TracksMap *map, void (*customdata_free)(void *custom
 		if (map->customdata && customdata_free)
 			customdata_free(&map->customdata[i * map->customdata_size]);
 
-		BKE_tracking_free_track(&map->tracks[i]);
+		BKE_tracking_track_free(&map->tracks[i]);
 	}
 
 	if (map->customdata)
@@ -1040,7 +1961,7 @@ static void tracks_map_free(TracksMap *map, void (*customdata_free)(void *custom
 	MEM_freeN(map);
 }
 
-/*********************** tracking *************************/
+/*********************** 2D tracking *************************/
 
 typedef struct TrackContext {
 #ifdef WITH_LIBMV
@@ -1073,16 +1994,33 @@ typedef struct MovieTrackingContext {
 	int sync_frame;
 } MovieTrackingContext;
 
+static void track_context_free(void *customdata)
+{
+	TrackContext *track_context = (TrackContext *)customdata;
+
+#if WITH_LIBMV
+	if (track_context->search_area)
+		MEM_freeN(track_context->search_area);
+
+	if (track_context->mask)
+		MEM_freeN(track_context->mask);
+
+#else
+	(void)track_context;
+#endif
+}
+
 MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *user, short backwards, short sequence)
 {
 	MovieTrackingContext *context = MEM_callocN(sizeof(MovieTrackingContext), "trackingContext");
 	MovieTracking *tracking = &clip->tracking;
 	MovieTrackingSettings *settings = &tracking->settings;
-	ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
+	ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
 	MovieTrackingTrack *track;
-	MovieTrackingObject *object = BKE_tracking_active_object(tracking);
+	MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
 	int num_tracks = 0;
 
+	context->clip = clip;
 	context->settings = *settings;
 	context->backwards = backwards;
 	context->sync_frame = user->framenr;
@@ -1094,7 +2032,7 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 	while (track) {
 		if (TRACK_SELECTED(track) && (track->flag & (TRACK_LOCKED | TRACK_HIDDEN)) == 0) {
 			int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
-			MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
+			MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
 
 			if ((marker->flag & MARKER_DISABLED) == 0)
 				num_tracks++;
@@ -1103,6 +2041,7 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 		track = track->next;
 	}
 
+	/* create tracking contextx for all tracks which would be tracked */
 	if (num_tracks) {
 		int width, height;
 
@@ -1116,7 +2055,7 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 		while (track) {
 			if (TRACK_SELECTED(track) && (track->flag & (TRACK_HIDDEN | TRACK_LOCKED)) == 0) {
 				int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
-				MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
+				MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
 
 				if ((marker->flag & MARKER_DISABLED) == 0) {
 					TrackContext track_context;
@@ -1129,8 +2068,6 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 		}
 	}
 
-	context->clip = clip;
-
 	/* store needed clip flags passing to get_buffer functions
 	 * - MCLIP_USE_PROXY is needed to because timecode affects on movie clip
 	 *   only in case Proxy/Timecode flag is set, so store this flag to use
@@ -1152,22 +2089,6 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 	return context;
 }
 
-static void track_context_free(void *customdata)
-{
-	TrackContext *track_context = (TrackContext *)customdata;
-
-#if WITH_LIBMV
-	if (track_context->search_area)
-		MEM_freeN(track_context->search_area);
-
-	if (track_context->mask)
-		MEM_freeN(track_context->mask);
-
-#else
-	(void)track_context;
-#endif
-}
-
 void BKE_tracking_context_free(MovieTrackingContext *context)
 {
 	if (!context->sequence)
@@ -1178,291 +2099,32 @@ void BKE_tracking_context_free(MovieTrackingContext *context)
 	MEM_freeN(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)
-{
-	int x, y;
-	float scale;
-
-	if (!disable_red && !disable_green && !disable_blue && !grayscale)
-		return;
-
-	/* If only some components are selected, it's important to rescale the result
-	 * appropriately so that e.g. if only blue is selected, it's not zeroed out.
-	 */
-	scale = (disable_red   ? 0.0f : 0.2126f) +
-	        (disable_green ? 0.0f : 0.7152f) +
-	        (disable_blue  ? 0.0f : 0.0722f);
-
-	for (y = 0; y < ibuf->y; y++) {
-		for (x = 0; x < ibuf->x; x++) {
-			int pixel = ibuf->x * y + x;
-
-			if (ibuf->rect_float) {
-				float *rrgbf = ibuf->rect_float + pixel * 4;
-				float r = disable_red   ? 0.0f : rrgbf[0];
-				float g = disable_green ? 0.0f : rrgbf[1];
-				float b = disable_blue  ? 0.0f : rrgbf[2];
-
-				if (grayscale) {
-					float gray = (0.2126f * r + 0.7152f * g + 0.0722f * b) / scale;
-
-					rrgbf[0] = rrgbf[1] = rrgbf[2] = gray;
-				}
-				else {
-					rrgbf[0] = r;
-					rrgbf[1] = g;
-					rrgbf[2] = b;
-				}
-			}
-			else {
-				char *rrgb = (char *)ibuf->rect + pixel * 4;
-				char r = disable_red   ? 0 : rrgb[0];
-				char g = disable_green ? 0 : rrgb[1];
-				char b = disable_blue  ? 0 : rrgb[2];
-
-				if (grayscale) {
-					float gray = (0.2126f * r + 0.7152f * g + 0.0722f * b) / scale;
-
-					rrgb[0] = rrgb[1] = rrgb[2] = gray;
-				}
-				else {
-					rrgb[0] = r;
-					rrgb[1] = g;
-					rrgb[2] = b;
-				}
-			}
-		}
-	}
-
-	if (ibuf->rect_float)
-		ibuf->userflags |= IB_RECT_INVALID;
-}
-
-static void disable_imbuf_channels(ImBuf *ibuf, MovieTrackingTrack *track, int grayscale)
-{
-	BKE_tracking_disable_imbuf_channels(ibuf, track->flag & TRACK_DISABLE_RED,
-	                                    track->flag & TRACK_DISABLE_GREEN, track->flag & TRACK_DISABLE_BLUE, grayscale);
-}
-
-ImBuf *BKE_tracking_sample_pattern_imbuf(int frame_width, int frame_height, ImBuf *search_ibuf,
-                                         MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                                         int use_mask, int num_samples_x, int num_samples_y,
-                                         float pos[2])
-{
-#ifdef WITH_LIBMV
-	ImBuf *pattern_ibuf;
-	double src_pixel_x[5], src_pixel_y[5];
-	double warped_position_x, warped_position_y;
-	float *mask = NULL;
-
-	pattern_ibuf = IMB_allocImBuf(num_samples_x, num_samples_y, 32, IB_rectfloat);
-	pattern_ibuf->profile = IB_PROFILE_LINEAR_RGB;
-
-	if (!search_ibuf->rect_float) {
-		IMB_float_from_rect(search_ibuf);
-	}
-
-	get_marker_coords_for_tracking(frame_width, frame_height, marker, src_pixel_x, src_pixel_y);
-
-	if (use_mask) {
-		mask = BKE_tracking_track_mask_get(frame_width, frame_height, track, marker);
-	}
-
-	libmv_samplePlanarPatch(search_ibuf->rect_float, search_ibuf->x, search_ibuf->y, 4,
-	                        src_pixel_x, src_pixel_y, num_samples_x,
-	                        num_samples_y, mask, pattern_ibuf->rect_float,
-	                        &warped_position_x, &warped_position_y);
-
-	if (pos) {
-		pos[0] = warped_position_x;
-		pos[1] = warped_position_y;
-	}
-
-	if (mask) {
-		MEM_freeN(mask);
-	}
-
-	return pattern_ibuf;
-#else
-	ImBuf *pattern_ibuf;
-
-	/* real sampling requires libmv, but areas are supposing pattern would be
-	 * sampled if search area does exists, so we'll need to create empty
-	 * pattern area here to prevent adding NULL-checks all over just to deal
-	 * with situation when lubmv is disabled
-	 */
-
-	(void) frame_width;
-	(void) frame_height;
-	(void) search_ibuf;
-	(void) marker;
-	(void) track;
-	(void) use_mask;
-
-	pattern_ibuf = IMB_allocImBuf(num_samples_x, num_samples_y, 32, IB_rectfloat);
-
-	pos[0] = num_samples_x / 2.0f;
-	pos[1] = num_samples_y / 2.0f;
-
-	return pattern_ibuf;
-#endif
-}
-
-ImBuf *BKE_tracking_get_pattern_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                                      int anchored, int disable_channels)
+void BKE_tracking_context_sync(MovieTrackingContext *context)
 {
-	ImBuf *pattern_ibuf, *search_ibuf;
-	float pat_min[2], pat_max[2];
-	int num_samples_x, num_samples_y;
-
-	BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
-
-	num_samples_x = (pat_max[0] - pat_min[0]) * ibuf->x;
-	num_samples_y = (pat_max[1] - pat_min[1]) * ibuf->y;
-
-	search_ibuf = BKE_tracking_get_search_imbuf(ibuf, track, marker, anchored, disable_channels);
-
-	pattern_ibuf = BKE_tracking_sample_pattern_imbuf(ibuf->x, ibuf->y, search_ibuf, track, marker,
-	                                                 FALSE, num_samples_x, num_samples_y, NULL);
-
-	IMB_freeImBuf(search_ibuf);
-
-	return pattern_ibuf;
-}
-
-ImBuf *BKE_tracking_get_search_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                                     int anchored, int disable_channels)
-{
-	ImBuf *searchibuf;
-	int x, y, w, h;
-	float search_origin[2];
-
-	get_search_origin_frame_pixel(ibuf->x, ibuf->y, marker, search_origin);
-
-	x = search_origin[0];
-	y = search_origin[1];
-
-	if (anchored) {
-		x += track->offset[0] * ibuf->x;
-		y += track->offset[1] * ibuf->y;
-	}
-
-	w = (marker->search_max[0] - marker->search_min[0]) * ibuf->x;
-	h = (marker->search_max[1] - marker->search_min[1]) * ibuf->y;
-
-	searchibuf = IMB_allocImBuf(w, h, 32, ibuf->rect_float ? IB_rectfloat : IB_rect);
-	searchibuf->profile = ibuf->profile;
-
-	IMB_rectcpy(searchibuf, ibuf, 0, 0, x, y, w, h);
-
-	if (disable_channels) {
-		if ((track->flag & TRACK_PREVIEW_GRAYSCALE) ||
-		    (track->flag & TRACK_DISABLE_RED)       ||
-		    (track->flag & TRACK_DISABLE_GREEN)     ||
-		    (track->flag & TRACK_DISABLE_BLUE))
-		{
-			disable_imbuf_channels(searchibuf, track, TRUE);
-		}
-	}
-
-	return searchibuf;
-}
-
-static bGPDlayer *track_mask_gpencil_layer_get(MovieTrackingTrack *track)
-{
-	bGPDlayer *layer;
-
-	if (!track->gpd)
-		return NULL;
-
-	layer = track->gpd->layers.first;
-
-	while (layer) {
-		if (layer->flag & GP_LAYER_ACTIVE) {
-			bGPDframe *frame = layer->frames.first;
-			int ok = FALSE;
-
-			while (frame) {
-				if (frame->strokes.first) {
-					ok = TRUE;
-				}
-
-				frame = frame->next;
-			}
-
-			if (ok)
-				return layer;
-		}
-
-		layer = layer->next;
-	}
-
-	return NULL;
-}
-
-static void track_mask_gpencil_layer_rasterize(int frame_width, int frame_height,
-											   MovieTrackingMarker *marker, bGPDlayer *layer,
-                                               float *mask, int mask_width, int mask_height)
-{
-	bGPDframe *frame = layer->frames.first;
-
-	while (frame) {
-		bGPDstroke *stroke = frame->strokes.first;
-
-		while (stroke) {
-			bGPDspoint *stroke_points = stroke->points;
-			float *mask_points, *fp;
-			int i;
-
-			if (stroke->flag & GP_STROKE_2DSPACE) {
-				fp = mask_points = MEM_callocN(2 * stroke->totpoints * sizeof(float),
-				                               "track mask rasterization points");
-
-				for (i = 0; i < stroke->totpoints; i++, fp += 2) {
-					fp[0] = (stroke_points[i].x - marker->search_min[0]) * frame_width / mask_width;
-					fp[1] = (stroke_points[i].y - marker->search_min[1]) * frame_height / mask_height;
-				}
+	MovieTracking *tracking = &context->clip->tracking;
+	int newframe;
 
-				PLX_raskterize((float (*)[2])mask_points, stroke->totpoints, mask, mask_width, mask_height, FALSE /* XXX- TODO: make on/off for AA*/);
+	tracks_map_merge(context->tracks_map, tracking);
 
-				MEM_freeN(mask_points);
-			}
+	if (context->backwards)
+		newframe = context->user.framenr + 1;
+	else
+		newframe = context->user.framenr - 1;
 
-			stroke = stroke->next;
-		}
+	context->sync_frame = newframe;
 
-		frame = frame->next;
-	}
+	tracking->dopesheet.ok = FALSE;
 }
 
-float *BKE_tracking_track_mask_get(int frame_width, int frame_height,
-                                   MovieTrackingTrack *track, MovieTrackingMarker *marker)
+void BKE_tracking_context_sync_user(const MovieTrackingContext *context, MovieClipUser *user)
 {
-	float *mask = NULL;
-	bGPDlayer *layer = track_mask_gpencil_layer_get(track);
-	int mask_width, mask_height;
-
-	mask_width = (marker->search_max[0] - marker->search_min[0]) * frame_width;
-	mask_height = (marker->search_max[1] - marker->search_min[1]) * frame_height;
-
-	if (layer) {
-		mask = MEM_callocN(mask_width * mask_height * sizeof(float), "track mask");
-
-		track_mask_gpencil_layer_rasterize(frame_width, frame_height, marker, layer,
-		                                   mask, mask_width, mask_height);
-	}
-
-	return mask;
+	user->framenr = context->sync_frame;
 }
 
 #ifdef WITH_LIBMV
+/* **** utility functions for tracking **** */
 
-/* Convert from float and byte RGBA to grayscale. Supports different coefficients for RGB. */
+/* convert from float and byte RGBA to grayscale. Supports different coefficients for RGB. */
 static void float_rgba_to_gray(const float *rgba, float *gray, int num_pixels,
                                float weight_red, float weight_green, float weight_blue)
 {
@@ -1483,12 +2145,12 @@ static void uint8_rgba_to_float_gray(const unsigned char *rgba, float *gray, int
 	for (i = 0; i < num_pixels; i++) {
 		const unsigned char *pixel = rgba + i * 4;
 
-		*gray++ = (weight_red * pixel[0] + weight_green * pixel[1] + weight_blue * pixel[2]) / 255.0f;
+		gray[i] = (weight_red * pixel[0] + weight_green * pixel[1] + weight_blue * pixel[2]) / 255.0f;
 	}
 }
 
-static float *get_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                                  int *width_r, int *height_r)
+static float *track_get_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+                                        int *width_r, int *height_r)
 {
 	ImBuf *searchibuf;
 	float *gray_pixels;
@@ -1499,9 +2161,6 @@ static float *get_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieT
 	width = searchibuf->x;
 	height = searchibuf->y;
 
-	*width_r = searchibuf->x;
-	*height_r = searchibuf->y;
-
 	gray_pixels = MEM_callocN(width * height * sizeof(float), "tracking floatBuf");
 
 	if (searchibuf->rect_float) {
@@ -1515,39 +2174,13 @@ static float *get_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieT
 
 	IMB_freeImBuf(searchibuf);
 
-	return gray_pixels;
-}
-
-static unsigned char *get_ucharbuf(ImBuf *ibuf)
-{
-	int x, y;
-	unsigned char *pixels, *cp;
-
-	cp = pixels = MEM_callocN(ibuf->x * ibuf->y * sizeof(unsigned char), "tracking ucharBuf");
-	for (y = 0; y < ibuf->y; y++) {
-		for (x = 0; x < ibuf->x; x++) {
-			int pixel = ibuf->x * y + x;
-
-			if (ibuf->rect_float) {
-				const float *rrgbf = ibuf->rect_float + pixel * 4;
-				const float grey_f = 0.2126f * rrgbf[0] + 0.7152f * rrgbf[1] + 0.0722f * rrgbf[2];
+	*width_r = width;
+	*height_r = height;
 
-				*cp = FTOCHAR(grey_f);
-			}
-			else {
-				const unsigned char *rrgb = (unsigned char *)ibuf->rect + pixel * 4;
-
-				*cp = 0.2126f * rrgb[0] + 0.7152f * rrgb[1] + 0.0722f * rrgb[2];
-			}
-
-			cp++;
-		}
-	}
-
-	return pixels;
+	return gray_pixels;
 }
 
-static ImBuf *get_frame_ibuf(MovieTrackingContext *context, int framenr)
+static ImBuf *tracking_context_get_frame_ibuf(MovieTrackingContext *context, int framenr)
 {
 	ImBuf *ibuf;
 	MovieClipUser user = context->user;
@@ -1559,13 +2192,11 @@ static ImBuf *get_frame_ibuf(MovieTrackingContext *context, int framenr)
 	return ibuf;
 }
 
-static ImBuf *get_keyframed_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track,
-                                 MovieTrackingMarker *marker, MovieTrackingMarker **marker_keyed)
+MovieTrackingMarker *tracking_context_get_keyframed_marker(MovieTrackingContext *context, MovieTrackingTrack *track,
+                                                           MovieTrackingMarker *marker)
 {
-	int framenr = marker->framenr;
 	int a = marker - track->markers;
-
-	*marker_keyed = marker;
+	MovieTrackingMarker *marker_keyed = marker;
 
 	while (a >= 0 && a < track->markersnr) {
 		int next = (context->backwards) ? a + 1 : a - 1;
@@ -1583,8 +2214,7 @@ static ImBuf *get_keyframed_ibuf(MovieTrackingContext *context, MovieTrackingTra
 		is_keyframed |= (cur_marker->flag & MARKER_TRACKED) == 0;
 
 		if (is_keyframed) {
-			framenr = cur_marker->framenr;
-			*marker_keyed = cur_marker;
+			marker_keyed = cur_marker;
 
 			break;
 		}
@@ -1592,19 +2222,34 @@ static ImBuf *get_keyframed_ibuf(MovieTrackingContext *context, MovieTrackingTra
 		a = next;
 	}
 
-	return get_frame_ibuf(context, framenr);
+	return marker_keyed;
+}
+
+static ImBuf *tracking_context_get_keyframed_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track,
+                                                  MovieTrackingMarker *marker, MovieTrackingMarker **marker_keyed_r)
+{
+	MovieTrackingMarker *marker_keyed;
+	int keyed_framenr;
+
+	marker_keyed = tracking_context_get_keyframed_marker(context, track, marker);
+	keyed_framenr = marker_keyed->framenr;
+
+	*marker_keyed_r = marker_keyed;
+
+	return tracking_context_get_frame_ibuf(context, keyed_framenr);
 }
 
-static ImBuf *get_adjust_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                              int curfra, MovieTrackingMarker **marker_keyed)
+static ImBuf *tracking_context_get_reference_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track,
+                                                  MovieTrackingMarker *marker, int curfra,
+                                                  MovieTrackingMarker **marker_keyed)
 {
 	ImBuf *ibuf = NULL;
 
 	if (track->pattern_match == TRACK_MATCH_KEYFRAME) {
-		ibuf = get_keyframed_ibuf(context, track, marker, marker_keyed);
+		ibuf = tracking_context_get_keyframed_ibuf(context, track, marker, marker_keyed);
 	}
 	else {
-		ibuf = get_frame_ibuf(context, curfra);
+		ibuf = tracking_context_get_frame_ibuf(context, curfra);
 
 		/* use current marker as keyframed position */
 		*marker_keyed = marker;
@@ -1613,7 +2258,78 @@ static ImBuf *get_adjust_ibuf(MovieTrackingContext *context, MovieTrackingTrack
 	return ibuf;
 }
 
-static void marker_search_scale_after_tracking(const MovieTrackingMarker *old_marker, MovieTrackingMarker *new_marker)
+static void track_context_update_reference(MovieTrackingContext *context, TrackContext *track_context,
+                                           MovieTrackingTrack *track, MovieTrackingMarker *marker, int curfra,
+                                           int frame_width, int frame_height)
+{
+	MovieTrackingMarker *marker_keyed = NULL;
+	ImBuf *reference_ibuf = NULL;
+	int width, height;
+
+	/* calculate patch for keyframed position */
+	reference_ibuf = tracking_context_get_reference_ibuf(context, track, marker, curfra, &marker_keyed);
+	track_context->marker = *marker_keyed;
+
+	if (track_context->search_area) {
+		MEM_freeN(track_context->search_area);
+	}
+
+	track_context->search_area = track_get_search_floatbuf(reference_ibuf, track, marker_keyed, &width, &height);
+	track_context->search_area_height = height;
+	track_context->search_area_width = width;
+
+	if ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_MASK) != 0) {
+		if (track_context->mask)
+			MEM_freeN(track_context->mask);
+
+		track_context->mask = BKE_tracking_track_get_mask(frame_width, frame_height, track, marker);
+	}
+
+	IMB_freeImBuf(reference_ibuf);
+}
+
+static void tracking_configure_tracker(TrackContext *track_context, MovieTrackingTrack *track,
+                                       struct libmv_trackRegionOptions *options)
+{
+	options->motion_model = track->motion_model;
+
+	options->use_brute = ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_BRUTE) != 0);
+
+	options->use_normalization = ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_NORMALIZATION) != 0);
+
+	options->num_iterations = 50;
+	options->minimum_correlation = track->minimum_correlation;
+	options->sigma = 0.9;
+
+	if ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_MASK) != 0)
+		options->image1_mask = track_context->mask;
+}
+
+/* returns FALSE if marker crossed margin area from frame bounds */
+static int tracking_check_marker_margin(MovieTrackingTrack *track, MovieTrackingMarker *marker,
+                                        int frame_width, int frame_height)
+{
+	float pat_min[2], pat_max[2], dim[2], margin[2];
+
+	/* margin from frame boundaries */
+	BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
+	sub_v2_v2v2(dim, pat_max, pat_min);
+	margin[0] = margin[1] = MAX2(dim[0], dim[1]) / 2.0f;
+
+	margin[0] = MAX2(margin[0], (float)track->margin / frame_width);
+	margin[1] = MAX2(margin[1], (float)track->margin / frame_height);
+
+	/* 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])
+	{
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void tracking_scale_marker_search(const MovieTrackingMarker *old_marker, MovieTrackingMarker *new_marker)
 {
 	float old_pat_min[2], old_pat_max[2];
 	float new_pat_min[2], new_pat_max[2];
@@ -1632,73 +2348,89 @@ static void marker_search_scale_after_tracking(const MovieTrackingMarker *old_ma
 	new_marker->search_max[1] *= scale_y;
 }
 
-#endif
-
-void BKE_tracking_sync(MovieTrackingContext *context)
+static void tracking_insert_new_marker(MovieTrackingContext *context, MovieTrackingTrack *track,
+                                       const MovieTrackingMarker *old_marker, int curfra, int tracked,
+                                       int frame_width, int frame_height,
+                                       double dst_pixel_x[5], double dst_pixel_y[5])
 {
-	MovieTracking *tracking = &context->clip->tracking;
-	int newframe;
+	MovieTrackingMarker new_marker;
+	int frame_delta = context->backwards ? -1 : 1;
+	int nextfra = curfra + frame_delta;
 
-	tracks_map_merge(context->tracks_map, tracking);
+	new_marker = *old_marker;
 
-	if (context->backwards)
-		newframe = context->user.framenr + 1;
-	else
-		newframe = context->user.framenr - 1;
+	if (tracked) {
+		set_marker_coords_from_tracking(frame_width, frame_height, &new_marker, dst_pixel_x, dst_pixel_y);
+		new_marker.flag |= MARKER_TRACKED;
+		new_marker.framenr = nextfra;
 
-	context->sync_frame = newframe;
+		tracking_scale_marker_search(old_marker, &new_marker);
 
-	tracking->dopesheet.ok = FALSE;
-}
+		if (context->first_time) {
+			/* check if there's no keyframe/tracked markers before tracking marker.
+			 * if so -- create disabled marker before currently tracking "segment"
+			 */
 
-void BKE_tracking_sync_user(MovieClipUser *user, MovieTrackingContext *context)
-{
-	user->framenr = context->sync_frame;
+			tracking_marker_insert_disabled(track, &new_marker, !context->backwards, FALSE);
+		}
+
+		/* insert currently tracked marker */
+		BKE_tracking_marker_insert(track, &new_marker);
+
+		/* make currently tracked segment be finished with disabled marker */
+		tracking_marker_insert_disabled(track, &new_marker, context->backwards, FALSE);
+	}
+	else {
+		new_marker.framenr = nextfra;
+		new_marker.flag |= MARKER_DISABLED;
+
+		BKE_tracking_marker_insert(track, &new_marker);
+	}
 }
 
-int BKE_tracking_next(MovieTrackingContext *context)
+#endif
+
+int BKE_tracking_context_step(MovieTrackingContext *context)
 {
 	ImBuf *destination_ibuf;
+	int frame_delta = context->backwards ? -1 : 1;
 	int curfra =  BKE_movieclip_remap_scene_to_clip_frame(context->clip, context->user.framenr);
+	int nextfra;
 	int a, ok = FALSE, map_size;
 
 	int frame_width, frame_height;
 
-	map_size = tracks_map_size(context->tracks_map);
+	map_size = tracks_map_get_size(context->tracks_map);
 
 	/* nothing to track, avoid unneeded frames reading to save time and memory */
 	if (!map_size)
 		return FALSE;
 
-	if (context->backwards)
-		context->user.framenr--;
-	else
-		context->user.framenr++;
+	context->user.framenr += frame_delta;
 
 	destination_ibuf = BKE_movieclip_get_ibuf_flag(context->clip, &context->user,
 	                                               context->clip_flag, MOVIECLIP_CACHE_SKIP);
 	if (!destination_ibuf)
 		return FALSE;
 
+	nextfra = curfra + frame_delta;
+
 	frame_width = destination_ibuf->x;
 	frame_height = destination_ibuf->y;
 
-	//#pragma omp parallel for private(a) shared(destination_ibuf, ok) if (map_size>1)
+	#pragma omp parallel for private(a) shared(destination_ibuf, ok) if (map_size>1)
 	for (a = 0; a < map_size; a++) {
 		TrackContext *track_context = NULL;
 		MovieTrackingTrack *track;
 		MovieTrackingMarker *marker;
 
-		tracks_map_get(context->tracks_map, a, &track, (void **)&track_context);
+		tracks_map_get_indexed_element(context->tracks_map, a, &track, (void **)&track_context);
 
-		marker = BKE_tracking_exact_marker(track, curfra);
+		marker = BKE_tracking_marker_get_exact(track, curfra);
 
 		if (marker && (marker->flag & MARKER_DISABLED) == 0) {
 #ifdef WITH_LIBMV
-			int width, height, tracked = 0, need_readjust = 0;
-			float margin[2], dim[2], pat_min[2], pat_max[2];
-			MovieTrackingMarker marker_new, *marker_keyed;
-			int onbound = FALSE, nextfra;
+			int width, height, tracked = FALSE, need_readjust;
 			double dst_pixel_x[5], dst_pixel_y[5];
 
 			if (track->pattern_match == TRACK_MATCH_KEYFRAME)
@@ -1706,29 +2438,10 @@ int BKE_tracking_next(MovieTrackingContext *context)
 			else
 				need_readjust = TRUE;
 
-			if (context->backwards)
-				nextfra = curfra - 1;
-			else
-				nextfra = curfra + 1;
-
-			/* margin from frame boundaries */
-			BKE_tracking_marker_pattern_minmax(marker, pat_min, pat_max);
-			sub_v2_v2v2(dim, pat_max, pat_min);
-			margin[0] = margin[1] = MAX2(dim[0], dim[1]) / 2.0f;
-
-			margin[0] = MAX2(margin[0], (float)track->margin / destination_ibuf->x);
-			margin[1] = MAX2(margin[1], (float)track->margin / destination_ibuf->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])
-			{
-				onbound = TRUE;
-			}
-			else {
+			if (tracking_check_marker_margin(track, marker, frame_width, frame_height)) {
 				/* to convert to the x/y split array format for libmv. */
-				double src_pixel_x[5];
-				double src_pixel_y[5];
+				double src_pixel_x[5], src_pixel_y[5];
 
 				/* settings for the tracker */
 				struct libmv_trackRegionOptions options = {0};
@@ -1737,57 +2450,24 @@ int BKE_tracking_next(MovieTrackingContext *context)
 				float *patch_new;
 
 				if (need_readjust) {
-					ImBuf *reference_ibuf = NULL;
-					/* calculate patch for keyframed position */
-					reference_ibuf = get_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
-					track_context->marker = *marker_keyed;
-
-					if (track_context->search_area)
-						MEM_freeN(track_context->search_area);
-
-					track_context->search_area = get_search_floatbuf(reference_ibuf, track,
-					                                                 marker_keyed, &width, &height);
-					track_context->search_area_height = height;
-					track_context->search_area_width = width;
-
-					IMB_freeImBuf(reference_ibuf);
-
-					if ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_MASK) != 0) {
-						if (track_context->mask)
-							MEM_freeN(track_context->mask);
-
-						track_context->mask = BKE_tracking_track_mask_get(frame_width, frame_height,
-						                                                  track, marker);
-					}
+					track_context_update_reference(context, track_context, track, marker,
+					                               curfra, frame_width, frame_height);
 				}
 
 				/* for now track to the same search area dimension as marker has got for current frame
 				 * will make all tracked markers in currently tracked segment have the same search area
 				 * size, but it's quite close to what is actually needed
 				 */
-				patch_new = get_search_floatbuf(destination_ibuf, track, marker, &width, &height);
-
-				/* Configure the tracker */
-				options.motion_model = track->motion_model;
-
-				options.use_brute =
-				    ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_BRUTE) != 0);
+				patch_new = track_get_search_floatbuf(destination_ibuf, track, marker, &width, &height);
 
-				options.use_normalization =
-				    ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_NORMALIZATION) != 0);
+				/* configure the tracker */
+				tracking_configure_tracker(track_context, track, &options);
 
-				options.num_iterations = 50;
-				options.minimum_correlation = track->minimum_correlation;
-				options.sigma = 0.9;
-
-				if ((track->algorithm_flag & TRACK_ALGORITHM_FLAG_USE_MASK) != 0)
-					options.image1_mask = track_context->mask;
-
-				/* Convert the marker corners and center into pixel coordinates in the search/destination images. */
+				/* convert the marker corners and center into pixel coordinates in the search/destination images. */
 				get_marker_coords_for_tracking(frame_width, frame_height, &track_context->marker, src_pixel_x, src_pixel_y);
 				get_marker_coords_for_tracking(frame_width, frame_height, marker, dst_pixel_x, dst_pixel_y);
 
-				/* Run the tracker! */
+				/* run the tracker! */
 				tracked = libmv_trackRegion(&options,
 				                            track_context->search_area,
 											track_context->search_area_width,
@@ -1799,42 +2479,10 @@ int BKE_tracking_next(MovieTrackingContext *context)
 				MEM_freeN(patch_new);
 			}
 
-			if (tracked && !onbound) {
-				memset(&marker_new, 0, sizeof(marker_new));
-				marker_new = *marker;
-				set_marker_coords_from_tracking(frame_width, frame_height, &marker_new, dst_pixel_x, dst_pixel_y);
-				marker_new.flag |= MARKER_TRACKED;
-				marker_new.framenr = nextfra;
-
-				marker_search_scale_after_tracking(marker, &marker_new);
-
-				//#pragma omp critical
-				{
-					if (context->first_time) {
-						/* check if there's no keyframe/tracked markers before tracking marker.
-						 * if so -- create disabled marker before currently tracking "segment"
-						 */
-
-						put_disabled_marker(track, &marker_new, !context->backwards, 0);
-					}
-
-					/* insert currently tracked marker */
-					BKE_tracking_insert_marker(track, &marker_new);
-
-					/* make currently tracked segment be finished with disabled marker */
-					put_disabled_marker(track, &marker_new, context->backwards, 0);
-				}
-			}
-			else {
-				marker_new = *marker;
-
-				marker_new.framenr = nextfra;
-				marker_new.flag |= MARKER_DISABLED;
-
-				//#pragma omp critical
-				{
-					BKE_tracking_insert_marker(track, &marker_new);
-				}
+			#pragma omp critical
+			{
+				tracking_insert_new_marker(context, track, marker, curfra, tracked,
+				                                 frame_width, frame_height, dst_pixel_x, dst_pixel_y);
 			}
 
 			ok = TRUE;
@@ -1853,7 +2501,7 @@ int BKE_tracking_next(MovieTrackingContext *context)
 	return ok;
 }
 
-/*********************** camera solving *************************/
+/*********************** Camera solving *************************/
 
 typedef struct MovieReconstructContext {
 #ifdef WITH_LIBMV
@@ -1886,8 +2534,8 @@ typedef struct ReconstructProgressData {
 	int message_size;
 } ReconstructProgressData;
 
-#if WITH_LIBMV
-static struct libmv_Tracks *create_libmv_tracks(ListBase *tracksbase, int width, int height)
+#ifdef WITH_LIBMV
+static struct libmv_Tracks *libmv_tracks_new(ListBase *tracksbase, int width, int height)
 {
 	int tracknr = 0;
 	MovieTrackingTrack *track;
@@ -1913,7 +2561,7 @@ static struct libmv_Tracks *create_libmv_tracks(ListBase *tracksbase, int width,
 	return tracks;
 }
 
-static void retrieve_libmv_reconstruct_intrinscis(MovieReconstructContext *context, MovieTracking *tracking)
+static void reconstruct_retrieve_libmv_intrinscis(MovieReconstructContext *context, MovieTracking *tracking)
 {
 	struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
 	struct libmv_CameraIntrinsics *libmv_intrinsics = libmv_ReconstructionExtractIntrinsics(libmv_reconstruction);
@@ -1934,7 +2582,7 @@ static void retrieve_libmv_reconstruct_intrinscis(MovieReconstructContext *conte
 	tracking->camera.k2 = k2;
 }
 
-static int retrieve_libmv_reconstruct_tracks(MovieReconstructContext *context, MovieTracking *tracking)
+static int reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, MovieTracking *tracking)
 {
 	struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
 	MovieTrackingReconstruction *reconstruction = NULL;
@@ -1950,7 +2598,7 @@ static int retrieve_libmv_reconstruct_tracks(MovieReconstructContext *context, M
 		reconstruction = &tracking->reconstruction;
 	}
 	else {
-		MovieTrackingObject *object = BKE_tracking_named_object(tracking, context->object_name);
+		MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
 
 		tracksbase = &object->tracks;
 		reconstruction = &object->reconstruction;
@@ -2042,15 +2690,15 @@ static int retrieve_libmv_reconstruct_tracks(MovieReconstructContext *context, M
 	return ok;
 }
 
-static int retrieve_libmv_reconstruct(MovieReconstructContext *context, MovieTracking *tracking)
+static int reconstruct_retrieve_libmv(MovieReconstructContext *context, MovieTracking *tracking)
 {
 	/* take the intrinscis back from libmv */
-	retrieve_libmv_reconstruct_intrinscis(context, tracking);
+	reconstruct_retrieve_libmv_intrinscis(context, tracking);
 
-	return retrieve_libmv_reconstruct_tracks(context, tracking);
+	return reconstruct_retrieve_libmv_tracks(context, tracking);
 }
 
-static int get_refine_intrinsics_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;
@@ -2073,7 +2721,7 @@ static int get_refine_intrinsics_flags(MovieTracking *tracking, MovieTrackingObj
 	return flags;
 }
 
-static int count_tracks_on_both_keyframes(MovieTracking *tracking, ListBase *tracksbase)
+static int reconstruct_count_tracks_on_both_keyframes(MovieTracking *tracking, ListBase *tracksbase)
 {
 	int tot = 0;
 	int frame1 = tracking->settings.keyframe1, frame2 = tracking->settings.keyframe2;
@@ -2081,9 +2729,11 @@ static int count_tracks_on_both_keyframes(MovieTracking *tracking, ListBase *tra
 
 	track = tracksbase->first;
 	while (track) {
-		if (BKE_tracking_has_enabled_marker(track, frame1))
-			if (BKE_tracking_has_enabled_marker(track, frame2))
+		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;
 	}
@@ -2092,16 +2742,16 @@ static int count_tracks_on_both_keyframes(MovieTracking *tracking, ListBase *tra
 }
 #endif
 
-int BKE_tracking_can_reconstruct(MovieTracking *tracking, MovieTrackingObject *object, char *error_msg, int error_size)
+int BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObject *object, char *error_msg, int error_size)
 {
 #if WITH_LIBMV
-	ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
+	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
 
 	if (tracking->settings.motion_flag & TRACKING_MOTION_MODAL) {
 		/* TODO: check for number of tracks? */
 		return TRUE;
 	}
-	else if (count_tracks_on_both_keyframes(tracking, tracksbase) < 8) {
+	else if (reconstruct_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);
 
@@ -2124,7 +2774,7 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieTracking *
 {
 	MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext), "MovieReconstructContext data");
 	MovieTrackingCamera *camera = &tracking->camera;
-	ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
+	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
 	float aspy = 1.0f / tracking->camera.pixel_aspect;
 	int num_tracks = BLI_countlist(tracksbase);
 	int sfra = INT_MAX, efra = INT_MIN;
@@ -2134,6 +2784,14 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieTracking *
 	context->is_camera = object->flag & TRACKING_OBJECT_CAMERA;
 	context->motion_flag = tracking->settings.motion_flag;
 
+	context->focal_length = camera->focal;
+	context->principal_point[0] = camera->principal[0];
+	context->principal_point[1] = camera->principal[1] * aspy;
+
+	context->k1 = camera->k1;
+	context->k2 = camera->k2;
+	context->k3 = camera->k3;
+
 	context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
 
 	track = tracksbase->first;
@@ -2169,10 +2827,10 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieTracking *
 	context->efra = efra;
 
 #ifdef WITH_LIBMV
-	context->tracks = create_libmv_tracks(tracksbase, width, height * aspy);
+	context->tracks = libmv_tracks_new(tracksbase, width, height * aspy);
 	context->keyframe1 = keyframe1;
 	context->keyframe2 = keyframe2;
-	context->refine_flags = get_refine_intrinsics_flags(tracking, object);
+	context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, object);
 #else
 	(void) width;
 	(void) height;
@@ -2180,14 +2838,6 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieTracking *
 	(void) keyframe2;
 #endif
 
-	context->focal_length = camera->focal;
-	context->principal_point[0] = camera->principal[0];
-	context->principal_point[1] = camera->principal[1] * aspy;
-
-	context->k1 = camera->k1;
-	context->k2 = camera->k2;
-	context->k3 = camera->k3;
-
 	return context;
 }
 
@@ -2206,7 +2856,7 @@ void BKE_tracking_reconstruction_context_free(MovieReconstructContext *context)
 }
 
 #ifdef WITH_LIBMV
-static void solve_reconstruction_update_cb(void *customdata, double progress, const char *message)
+static void reconstruct_update_solve_cb(void *customdata, double progress, const char *message)
 {
 	ReconstructProgressData *progressdata = customdata;
 
@@ -2231,7 +2881,7 @@ static int solve_reconstruction_testbreak_cb(void *customdata)
 }
 #endif
 
-void BKE_tracking_solve_reconstruction(MovieReconstructContext *context, short *stop, short *do_update,
+void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *stop, short *do_update,
                                        float *progress, char *stats_message, int message_size)
 {
 #ifdef WITH_LIBMV
@@ -2250,7 +2900,7 @@ void BKE_tracking_solve_reconstruction(MovieReconstructContext *context, short *
 		                                           context->focal_length,
 		                                           context->principal_point[0], context->principal_point[1],
 		                                           context->k1, context->k2, context->k3,
-		                                           solve_reconstruction_update_cb, &progressdata);
+		                                           reconstruct_update_solve_cb, &progressdata);
 	}
 	else {
 		context->reconstruction = libmv_solveReconstruction(context->tracks,
@@ -2259,7 +2909,7 @@ void BKE_tracking_solve_reconstruction(MovieReconstructContext *context, short *
 		                                                    context->focal_length,
 		                                                    context->principal_point[0], context->principal_point[1],
 		                                                    context->k1, context->k2, context->k3,
-		                                                    solve_reconstruction_update_cb, &progressdata);
+		                                                    reconstruct_update_solve_cb, &progressdata);
 	}
 
 	error = libmv_reprojectionError(context->reconstruction);
@@ -2275,7 +2925,7 @@ void BKE_tracking_solve_reconstruction(MovieReconstructContext *context, short *
 #endif
 }
 
-int BKE_tracking_finish_reconstruction(MovieReconstructContext *context, MovieTracking *tracking)
+int BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTracking *tracking)
 {
 	MovieTrackingReconstruction *reconstruction;
 
@@ -2287,7 +2937,7 @@ int BKE_tracking_finish_reconstruction(MovieReconstructContext *context, MovieTr
 	else {
 		MovieTrackingObject *object;
 
-		object = BKE_tracking_named_object(tracking, context->object_name);
+		object = BKE_tracking_object_get_named(tracking, context->object_name);
 		reconstruction = &object->reconstruction;
 	}
 
@@ -2295,350 +2945,17 @@ int BKE_tracking_finish_reconstruction(MovieReconstructContext *context, MovieTr
 	reconstruction->flag |= TRACKING_RECONSTRUCTED;
 
 #ifdef WITH_LIBMV
-	if (!retrieve_libmv_reconstruct(context, tracking))
+	if (!reconstruct_retrieve_libmv(context, tracking))
 		return FALSE;
 #endif
 
 	return TRUE;
 }
 
-void BKE_track_unique_name(ListBase *tracksbase, MovieTrackingTrack *track)
-{
-	BLI_uniquename(tracksbase, track, "Track", '.', offsetof(MovieTrackingTrack, name), sizeof(track->name));
-}
-
-MovieTrackingTrack *BKE_tracking_named_track(MovieTracking *tracking, MovieTrackingObject *object, const char *name)
-{
-	ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
-	MovieTrackingTrack *track = tracksbase->first;
-
-	while (track) {
-		if (!strcmp(track->name, name))
-			return track;
-
-		track = track->next;
-	}
-
-	return NULL;
-}
-
-static int reconstruction_camera_index(MovieTrackingReconstruction *reconstruction, int framenr, int nearest)
-{
-	MovieReconstructedCamera *cameras = reconstruction->cameras;
-	int a = 0, d = 1;
-
-	if (!reconstruction->camnr)
-		return -1;
-
-	if (framenr < cameras[0].framenr) {
-		if (nearest)
-			return 0;
-		else
-			return -1;
-	}
-
-	if (framenr > cameras[reconstruction->camnr - 1].framenr) {
-		if (nearest)
-			return reconstruction->camnr - 1;
-		else
-			return -1;
-	}
-
-	if (reconstruction->last_camera < reconstruction->camnr)
-		a = reconstruction->last_camera;
-
-	if (cameras[a].framenr >= framenr)
-		d = -1;
-
-	while (a >= 0 && a < reconstruction->camnr) {
-		int cfra = cameras[a].framenr;
-
-		/* check if needed framenr was "skipped" -- no data for requested frame */
-
-		if (d > 0 && cfra > framenr) {
-			/* interpolate with previous position */
-			if (nearest)
-				return a - 1;
-			else
-				break;
-		}
-
-		if (d < 0 && cfra < framenr) {
-			/* interpolate with next position */
-			if (nearest)
-				return a;
-			else
-				break;
-		}
-
-		if (cfra == framenr) {
-			reconstruction->last_camera = a;
-
-			return a;
-		}
-
-		a += d;
-	}
-
-	return -1;
-}
-
-static void scale_reconstructed_camera(MovieTrackingObject *object, float mat[4][4])
-{
-	if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) {
-		float smat[4][4];
-
-		scale_m4_fl(smat, 1.0f / object->scale);
-		mult_m4_m4m4(mat, mat, smat);
-	}
-}
-
-MovieReconstructedCamera *BKE_tracking_get_reconstructed_camera(MovieTracking *tracking,
-                                                                MovieTrackingObject *object, int framenr)
-{
-	MovieTrackingReconstruction *reconstruction;
-	int a;
-
-	reconstruction = BKE_tracking_object_reconstruction(tracking, object);
-	a = reconstruction_camera_index(reconstruction, framenr, FALSE);
-
-	if (a == -1)
-		return NULL;
-
-	return &reconstruction->cameras[a];
-}
-
-void BKE_tracking_get_interpolated_camera(MovieTracking *tracking, MovieTrackingObject *object,
-                                          int framenr, float mat[4][4])
-{
-	MovieTrackingReconstruction *reconstruction;
-	MovieReconstructedCamera *cameras;
-	int a;
-
-	reconstruction = BKE_tracking_object_reconstruction(tracking, object);
-	cameras = reconstruction->cameras;
-	a = reconstruction_camera_index(reconstruction, framenr, 1);
-
-	if (a == -1) {
-		unit_m4(mat);
-
-		return;
-	}
-
-	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);
-
-		blend_m4_m4m4(mat, cameras[a].mat, cameras[a + 1].mat, t);
-	}
-	else {
-		copy_m4_m4(mat, cameras[a].mat);
-	}
-
-	scale_reconstructed_camera(object, mat);
-}
-
-void BKE_get_tracking_mat(Scene *scene, Object *ob, float mat[4][4])
-{
-	if (!ob) {
-		if (scene->camera)
-			ob = scene->camera;
-		else
-			ob = BKE_scene_camera_find(scene);
-	}
-
-	if (ob)
-		BKE_object_where_is_calc_mat4(scene, ob, mat);
-	else
-		unit_m4(mat);
-}
-
-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;
-}
-
-void BKE_tracking_camera_to_blender(MovieTracking *tracking, Scene *scene, Camera *camera, int width, int height)
-{
-	float focal = tracking->camera.focal;
-
-	camera->sensor_x = tracking->camera.sensor_width;
-	camera->sensor_fit = CAMERA_SENSOR_FIT_AUTO;
-	camera->lens = focal * camera->sensor_x / width;
-
-	scene->r.xsch = width * tracking->camera.pixel_aspect;
-	scene->r.ysch = height;
-
-	scene->r.xasp = 1.0f;
-	scene->r.yasp = 1.0f;
-
-	BKE_tracking_camera_shift(tracking, width, height, &camera->shiftx, &camera->shifty);
-}
-
-void BKE_tracking_projection_matrix(MovieTracking *tracking, MovieTrackingObject *object,
-                                    int framenr, int winx, int winy, float mat[4][4])
-{
-	MovieReconstructedCamera *camera;
-	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;
-	float shiftx, shifty, winside = MAX2(winx, winy);
-
-	BKE_tracking_camera_shift(tracking, winx, winy, &shiftx, &shifty);
-
-	clipsta = 0.1f;
-	clipend = 1000.0f;
-
-	if (winx >= winy)
-		viewfac = (lens * winx) / tracking->camera.sensor_width;
-	else
-		viewfac = (ycor * lens * winy) / tracking->camera.sensor_width;
-
-	pixsize = clipsta / viewfac;
-
-	left = -0.5f * (float)winx + shiftx * winside;
-	bottom = -0.5f * (ycor) * (float)winy + shifty * winside;
-	right =  0.5f * (float)winx + shiftx * winside;
-	top =  0.5f * (ycor) * (float)winy + shifty * winside;
-
-	left *= pixsize;
-	right *= pixsize;
-	bottom *= pixsize;
-	top *= pixsize;
-
-	perspective_m4(winmat, left, right, bottom, top, clipsta, clipend);
-
-	camera = BKE_tracking_get_reconstructed_camera(tracking, object, framenr);
-
-	if (camera) {
-		float imat[4][4];
-
-		invert_m4_m4(imat, camera->mat);
-		mult_m4_m4m4(mat, winmat, imat);
-	}
-	else copy_m4_m4(mat, winmat);
-}
-
-ListBase *BKE_tracking_get_tracks(MovieTracking *tracking)
-{
-	MovieTrackingObject *object = BKE_tracking_active_object(tracking);
-
-	if (object && (object->flag & TRACKING_OBJECT_CAMERA) == 0) {
-		return &object->tracks;
-	}
-
-	return &tracking->tracks;
-}
-
-MovieTrackingTrack *BKE_tracking_active_track(MovieTracking *tracking)
-{
-	ListBase *tracksbase;
-
-	if (!tracking->act_track)
-		return NULL;
-
-	tracksbase = BKE_tracking_get_tracks(tracking);
-
-	/* check that active track is in current tracks list */
-	if (BLI_findindex(tracksbase, tracking->act_track) >= 0)
-		return tracking->act_track;
-
-	return NULL;
-}
-
-MovieTrackingObject *BKE_tracking_active_object(MovieTracking *tracking)
-{
-	return BLI_findlink(&tracking->objects, tracking->objectnr);
-}
-
-MovieTrackingObject *BKE_tracking_get_camera_object(MovieTracking *tracking)
-{
-	MovieTrackingObject *object = tracking->objects.first;
-
-	while (object) {
-		if (object->flag & TRACKING_OBJECT_CAMERA)
-			return object;
-
-		object = object->next;
-	}
-
-	return NULL;
-}
-
-ListBase *BKE_tracking_object_tracks(MovieTracking *tracking, MovieTrackingObject *object)
-{
-	if (object->flag & TRACKING_OBJECT_CAMERA) {
-		return &tracking->tracks;
-	}
-
-	return &object->tracks;
-}
-
-MovieTrackingReconstruction *BKE_tracking_object_reconstruction(MovieTracking *tracking, MovieTrackingObject *object)
-{
-	if (object->flag & TRACKING_OBJECT_CAMERA) {
-		return &tracking->reconstruction;
-	}
-
-	return &object->reconstruction;
-}
-
-MovieTrackingReconstruction *BKE_tracking_get_reconstruction(MovieTracking *tracking)
-{
-	MovieTrackingObject *object = BKE_tracking_active_object(tracking);
-
-	return BKE_tracking_object_reconstruction(tracking, object);
-}
-
-void BKE_tracking_apply_intrinsics(MovieTracking *tracking, float co[2], float nco[2])
-{
-	MovieTrackingCamera *camera = &tracking->camera;
+/*********************** Feature detection *************************/
 
 #ifdef WITH_LIBMV
-	double x, y;
-	float aspy = 1.0f / tracking->camera.pixel_aspect;
-
-	/* normalize coords */
-	x = (co[0] - camera->principal[0]) / camera->focal;
-	y = (co[1] - camera->principal[1] * aspy) / camera->focal;
-
-	libmv_applyCameraIntrinsics(camera->focal, camera->principal[0], camera->principal[1] * aspy,
-	                            camera->k1, camera->k2, camera->k3, x, y, &x, &y);
-
-	/* result is in image coords already */
-	nco[0] = x;
-	nco[1] = y;
-#else
-	(void) camera;
-	(void) co;
-	(void) nco;
-#endif
-}
-
-void BKE_tracking_invert_intrinsics(MovieTracking *tracking, float co[2], float nco[2])
-{
-	MovieTrackingCamera *camera = &tracking->camera;
-
-#ifdef WITH_LIBMV
-	double x = co[0], y = co[1];
-	float aspy = 1.0f / tracking->camera.pixel_aspect;
-
-	libmv_InvertIntrinsics(camera->focal, camera->principal[0], camera->principal[1] * aspy,
-	                       camera->k1, camera->k2, camera->k3, x, y, &x, &y);
-
-	nco[0] = x * camera->focal + camera->principal[0];
-	nco[1] = y * camera->focal + camera->principal[1] * aspy;
-#else
-	(void) camera;
-	(void) co;
-	(void) nco;
-#endif
-}
-
-#ifdef WITH_LIBMV
-static int point_in_stroke(bGPDstroke *stroke, float x, float y)
+static int check_point_in_stroke(bGPDstroke *stroke, float x, float y)
 {
 	int i, prev;
 	int count = 0;
@@ -2660,7 +2977,7 @@ static int point_in_stroke(bGPDstroke *stroke, float x, float y)
 	return count % 2;
 }
 
-static int point_in_layer(bGPDlayer *layer, float x, float y)
+static int check_point_in_layer(bGPDlayer *layer, float x, float y)
 {
 	bGPDframe *frame = layer->frames.first;
 
@@ -2668,7 +2985,7 @@ static int point_in_layer(bGPDlayer *layer, float x, float y)
 		bGPDstroke *stroke = frame->strokes.first;
 
 		while (stroke) {
-			if (point_in_stroke(stroke, x, y))
+			if (check_point_in_stroke(stroke, x, y))
 				return TRUE;
 
 			stroke = stroke->next;
@@ -2679,9 +2996,9 @@ static int point_in_layer(bGPDlayer *layer, float x, float y)
 	return FALSE;
 }
 
-static void retrieve_libmv_features(MovieTracking *tracking, ListBase *tracksbase,
-                                    struct libmv_Features *features, int framenr, int width, int height,
-                                    bGPDlayer *layer, int place_outside_layer)
+static void detect_retrieve_libmv_features(MovieTracking *tracking, ListBase *tracksbase,
+                                           struct libmv_Features *features, int framenr, int width, int height,
+                                           bGPDlayer *layer, int place_outside_layer)
 {
 	int a;
 
@@ -2698,16 +3015,45 @@ static void retrieve_libmv_features(MovieTracking *tracking, ListBase *tracksbas
 		yu = y / height;
 
 		if (layer)
-			ok = point_in_layer(layer, xu, yu) != place_outside_layer;
+			ok = check_point_in_layer(layer, xu, yu) != place_outside_layer;
 
 		if (ok) {
-			track = BKE_tracking_add_track(tracking, tracksbase, xu, yu, framenr, width, height);
+			track = BKE_tracking_track_add(tracking, tracksbase, xu, yu, framenr, width, height);
 			track->flag |= SELECT;
 			track->pat_flag |= SELECT;
 			track->search_flag |= SELECT;
 		}
 	}
 }
+
+static unsigned char *detect_get_frame_ucharbuf(ImBuf *ibuf)
+{
+	int x, y;
+	unsigned char *pixels, *cp;
+
+	cp = pixels = MEM_callocN(ibuf->x * ibuf->y * sizeof(unsigned char), "tracking ucharBuf");
+	for (y = 0; y < ibuf->y; y++) {
+		for (x = 0; x < ibuf->x; x++) {
+			int pixel = ibuf->x * y + x;
+
+			if (ibuf->rect_float) {
+				const float *rrgbf = ibuf->rect_float + pixel * 4;
+				const float grey_f = 0.2126f * rrgbf[0] + 0.7152f * rrgbf[1] + 0.0722f * rrgbf[2];
+
+				*cp = FTOCHAR(grey_f);
+			}
+			else {
+				const unsigned char *rrgb = (unsigned char *)ibuf->rect + pixel * 4;
+
+				*cp = 0.2126f * rrgb[0] + 0.7152f * rrgb[1] + 0.0722f * rrgb[2];
+			}
+
+			cp++;
+		}
+	}
+
+	return pixels;
+}
 #endif
 
 void BKE_tracking_detect_fast(MovieTracking *tracking, ListBase *tracksbase, ImBuf *ibuf,
@@ -2716,14 +3062,14 @@ void BKE_tracking_detect_fast(MovieTracking *tracking, ListBase *tracksbase, ImB
 {
 #ifdef WITH_LIBMV
 	struct libmv_Features *features;
-	unsigned char *pixels = get_ucharbuf(ibuf);
+	unsigned char *pixels = detect_get_frame_ucharbuf(ibuf);
 
 	features = libmv_detectFeaturesFAST(pixels, ibuf->x, ibuf->y, ibuf->x,
 	                                    margin, min_trackness, min_distance);
 
 	MEM_freeN(pixels);
 
-	retrieve_libmv_features(tracking, tracksbase, features, framenr,
+	detect_retrieve_libmv_features(tracking, tracksbase, features, framenr,
 	                        ibuf->x, ibuf->y, layer, place_outside_layer);
 
 	libmv_destroyFeatures(features);
@@ -2740,38 +3086,9 @@ void BKE_tracking_detect_fast(MovieTracking *tracking, ListBase *tracksbase, ImB
 #endif
 }
 
-MovieTrackingTrack *BKE_tracking_indexed_track(MovieTracking *tracking, int tracknr, ListBase **tracksbase_r)
-{
-	MovieTrackingObject *object;
-	int cur = 1;
-
-	object = tracking->objects.first;
-	while (object) {
-		ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
-		MovieTrackingTrack *track = tracksbase->first;
-
-		while (track) {
-			if (track->flag & TRACK_HAS_BUNDLE) {
-				if (cur == tracknr) {
-					*tracksbase_r = tracksbase;
-					return track;
-				}
-
-				cur++;
-			}
-
-			track = track->next;
-		}
-
-		object = object->next;
-	}
-
-	*tracksbase_r = NULL;
+/*********************** 2D stabilization *************************/
 
-	return NULL;
-}
-
-static int stabilization_median_point(MovieTracking *tracking, int framenr, float median[2])
+static int stabilization_median_point_get(MovieTracking *tracking, int framenr, float median[2])
 {
 	int ok = FALSE;
 	float min[2], max[2];
@@ -2782,7 +3099,7 @@ static int stabilization_median_point(MovieTracking *tracking, int framenr, floa
 	track = tracking->tracks.first;
 	while (track) {
 		if (track->flag & TRACK_USE_2D_STAB) {
-			MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
+			MovieTrackingMarker *marker = BKE_tracking_marker_get(track, framenr);
 
 			DO_MINMAX2(marker->pos, min, max);
 
@@ -2798,8 +3115,9 @@ static int stabilization_median_point(MovieTracking *tracking, int framenr, floa
 	return ok;
 }
 
-static void calculate_stabdata(MovieTracking *tracking, int framenr, float width, float height,
-                               float firstmedian[2], float median[2], float loc[2], float *scale, float *angle)
+static void stabilization_calculate_data(MovieTracking *tracking, int framenr, float width, float height,
+                                         float firstmedian[2], float median[2], float loc[2],
+                                         float *scale, float *angle)
 {
 	MovieTrackingStabilization *stab = &tracking->stabilization;
 
@@ -2817,12 +3135,12 @@ static void calculate_stabdata(MovieTracking *tracking, int framenr, float width
 		float x0 = (float)width / 2.0f, y0 = (float)height / 2.0f;
 		float x = median[0] * width, y = median[1] * height;
 
-		marker = BKE_tracking_get_marker(stab->rot_track, 1);
+		marker = BKE_tracking_marker_get(stab->rot_track, 1);
 		sub_v2_v2v2(a, marker->pos, firstmedian);
 		a[0] *= width;
 		a[1] *= height;
 
-		marker = BKE_tracking_get_marker(stab->rot_track, framenr);
+		marker = BKE_tracking_marker_get(stab->rot_track, framenr);
 		sub_v2_v2v2(b, marker->pos, median);
 		b[0] *= width;
 		b[1] *= height;
@@ -2836,7 +3154,7 @@ static void calculate_stabdata(MovieTracking *tracking, int framenr, float width
 	}
 }
 
-static float stabilization_auto_scale_factor(MovieTracking *tracking, int width, int height)
+static float stabilization_calculate_autoscale_factor(MovieTracking *tracking, int width, int height)
 {
 	float firstmedian[2];
 	MovieTrackingStabilization *stab = &tracking->stabilization;
@@ -2845,7 +3163,7 @@ static float stabilization_auto_scale_factor(MovieTracking *tracking, int width,
 	if (stab->ok)
 		return stab->scale;
 
-	if (stabilization_median_point(tracking, 1, firstmedian)) {
+	if (stabilization_median_point_get(tracking, 1, firstmedian)) {
 		int sfra = INT_MAX, efra = INT_MIN, cfra;
 		float scale = 1.0f;
 		MovieTrackingTrack *track;
@@ -2872,11 +3190,11 @@ static float stabilization_auto_scale_factor(MovieTracking *tracking, int width,
 			float points[4][2] = {{0.0f, 0.0f}, {0.0f, height}, {width, height}, {width, 0.0f}};
 			float si, co;
 
-			stabilization_median_point(tracking, cfra, median);
+			stabilization_median_point_get(tracking, cfra, median);
 
-			calculate_stabdata(tracking, cfra, width, height, firstmedian, median, loc, &tmp_scale, &angle);
+			stabilization_calculate_data(tracking, cfra, width, height, firstmedian, median, loc, &tmp_scale, &angle);
 
-			BKE_tracking_stabdata_to_mat4(width, height, aspect, loc, 1.0f, angle, mat);
+			BKE_tracking_stabilization_data_to_mat4(width, height, aspect, loc, 1.0f, angle, mat);
 
 			si = sin(angle);
 			co = cos(angle);
@@ -2954,7 +3272,7 @@ static float stabilization_auto_scale_factor(MovieTracking *tracking, int width,
 	return stab->scale;
 }
 
-static ImBuf *stabilize_alloc_ibuf(ImBuf *cacheibuf, ImBuf *srcibuf, int fill)
+static ImBuf *stabilization_allocate_ibuf(ImBuf *cacheibuf, ImBuf *srcibuf, int fill)
 {
 	int flags;
 
@@ -2983,8 +3301,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_get(MovieTracking *tracking, int framenr, int width, int height,
+                                         float loc[2], float *scale, float *angle)
 {
 	float firstmedian[2], median[2];
 	MovieTrackingStabilization *stab = &tracking->stabilization;
@@ -2997,22 +3315,22 @@ void BKE_tracking_stabilization_data(MovieTracking *tracking, int framenr, int w
 		return;
 	}
 
-	if (stabilization_median_point(tracking, 1, firstmedian)) {
-		stabilization_median_point(tracking, framenr, median);
+	if (stabilization_median_point_get(tracking, 1, firstmedian)) {
+		stabilization_median_point_get(tracking, framenr, median);
 
 		if ((stab->flag & TRACKING_AUTOSCALE) == 0)
 			stab->scale = 1.0f;
 
 		if (!stab->ok) {
 			if (stab->flag & TRACKING_AUTOSCALE)
-				stabilization_auto_scale_factor(tracking, width, height);
+				stabilization_calculate_autoscale_factor(tracking, width, height);
 
-			calculate_stabdata(tracking, framenr, width, height, firstmedian, median, loc, scale, angle);
+			stabilization_calculate_data(tracking, framenr, width, height, firstmedian, median, loc, scale, angle);
 
 			stab->ok = TRUE;
 		}
 		else {
-			calculate_stabdata(tracking, framenr, width, height, firstmedian, median, loc, scale, angle);
+			stabilization_calculate_data(tracking, framenr, width, height, firstmedian, median, loc, scale, angle);
 		}
 	}
 	else {
@@ -3022,8 +3340,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_frame(MovieTracking *tracking, int framenr, ImBuf *ibuf,
+                                    float loc[2], float *scale, float *angle)
 {
 	float tloc[2], tscale, tangle;
 	MovieTrackingStabilization *stab = &tracking->stabilization;
@@ -3047,17 +3365,17 @@ ImBuf *BKE_tracking_stabilize(MovieTracking *tracking, int framenr, ImBuf *ibuf,
 		return ibuf;
 	}
 
-	BKE_tracking_stabilization_data(tracking, framenr, width, height, tloc, &tscale, &tangle);
+	BKE_tracking_stabilization_data_get(tracking, framenr, width, height, tloc, &tscale, &tangle);
 
-	tmpibuf = stabilize_alloc_ibuf(NULL, ibuf, TRUE);
+	tmpibuf = stabilization_allocate_ibuf(NULL, ibuf, TRUE);
 
 	/* scale would be handled by matrix transformation when angle is non-zero */
 	if (tscale != 1.0f && tangle == 0.0f) {
 		ImBuf *scaleibuf;
 
-		stabilization_auto_scale_factor(tracking, width, height);
+		stabilization_calculate_autoscale_factor(tracking, width, height);
 
-		scaleibuf = stabilize_alloc_ibuf(stab->scaleibuf, ibuf, 0);
+		scaleibuf = stabilization_allocate_ibuf(stab->scaleibuf, ibuf, 0);
 		stab->scaleibuf = scaleibuf;
 
 		IMB_rectcpy(scaleibuf, ibuf, 0, 0, 0, 0, ibuf->x, ibuf->y);
@@ -3080,7 +3398,7 @@ ImBuf *BKE_tracking_stabilize(MovieTracking *tracking, int framenr, ImBuf *ibuf,
 		int i, j, filter = tracking->stabilization.filter;
 		void (*interpolation)(struct ImBuf *, struct ImBuf *, float, float, int, int) = NULL;
 
-		BKE_tracking_stabdata_to_mat4(ibuf->x, ibuf->y, aspect, tloc, tscale, tangle, mat);
+		BKE_tracking_stabilization_data_to_mat4(ibuf->x, ibuf->y, aspect, tloc, tscale, tangle, mat);
 		invert_m4(mat);
 
 		if (filter == TRACKING_FILTER_NEAREAST)
@@ -3121,8 +3439,8 @@ 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_stabilization_data_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};
@@ -3150,241 +3468,7 @@ void BKE_tracking_stabdata_to_mat4(int width, int height, float aspect,
 	mul_serie_m4(mat, lmat, cmat, amat, rmat, iamat, smat, icmat, NULL);
 }
 
-MovieDistortion *BKE_tracking_distortion_create(void)
-{
-	MovieDistortion *distortion;
-
-	distortion = MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
-
-	return distortion;
-}
-
-MovieDistortion *BKE_tracking_distortion_copy(MovieDistortion *distortion)
-{
-	MovieDistortion *new_distortion;
-
-	new_distortion = MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
-
-#ifdef WITH_LIBMV
-	new_distortion->intrinsics = libmv_CameraIntrinsicsCopy(distortion->intrinsics);
-#else
-	(void) distortion;
-#endif
-
-	return new_distortion;
-}
-
-void BKE_tracking_distortion_update(MovieDistortion *distortion, MovieTracking *tracking, int width, int height)
-{
-	MovieTrackingCamera *camera = &tracking->camera;
-	float aspy = 1.0f / tracking->camera.pixel_aspect;
-
-#ifdef WITH_LIBMV
-	if (!distortion->intrinsics) {
-		distortion->intrinsics = libmv_CameraIntrinsicsNew(camera->focal,
-		                                                   camera->principal[0], camera->principal[1] * aspy,
-		                                                   camera->k1, camera->k2, camera->k3, width, height * aspy);
-	}
-	else {
-		libmv_CameraIntrinsicsUpdate(distortion->intrinsics, camera->focal,
-		                             camera->principal[0], camera->principal[1] * aspy,
-		                             camera->k1, camera->k2, camera->k3, width, height * aspy);
-	}
-#else
-	(void) distortion;
-	(void) width;
-	(void) height;
-	(void) camera;
-	(void) aspy;
-#endif
-}
-
-ImBuf *BKE_tracking_distortion_exec(MovieDistortion *distortion, MovieTracking *tracking,
-                                    ImBuf *ibuf, int width, int height, float overscan, int undistort)
-{
-	ImBuf *resibuf;
-
-	BKE_tracking_distortion_update(distortion, tracking, width, height);
-
-	resibuf = IMB_dupImBuf(ibuf);
-
-	if (ibuf->rect_float) {
-#ifdef WITH_LIBMV
-		if (undistort) {
-			libmv_CameraIntrinsicsUndistortFloat(distortion->intrinsics,
-			                                     ibuf->rect_float, resibuf->rect_float,
-			                                     ibuf->x, ibuf->y, overscan, ibuf->channels);
-		}
-		else {
-			libmv_CameraIntrinsicsDistortFloat(distortion->intrinsics,
-			                                   ibuf->rect_float, resibuf->rect_float,
-			                                   ibuf->x, ibuf->y, overscan, ibuf->channels);
-		}
-#endif
-
-		resibuf->userflags |= IB_RECT_INVALID;
-	}
-	else {
-#ifdef WITH_LIBMV
-		if (undistort) {
-			libmv_CameraIntrinsicsUndistortByte(distortion->intrinsics,
-			                                    (unsigned char *)ibuf->rect, (unsigned char *)resibuf->rect,
-			                                    ibuf->x, ibuf->y, overscan, ibuf->channels);
-		}
-		else {
-			libmv_CameraIntrinsicsDistortByte(distortion->intrinsics,
-			                                  (unsigned char *)ibuf->rect, (unsigned char *)resibuf->rect,
-			                                  ibuf->x, ibuf->y, overscan, ibuf->channels);
-		}
-#endif
-	}
-
-#ifndef WITH_LIBMV
-	(void) overscan;
-	(void) undistort;
-#endif
-
-	return resibuf;
-}
-
-void BKE_tracking_distortion_destroy(MovieDistortion *distortion)
-{
-#ifdef WITH_LIBMV
-	libmv_CameraIntrinsicsDestroy(distortion->intrinsics);
-#endif
-
-	MEM_freeN(distortion);
-}
-
-ImBuf *BKE_tracking_undistort(MovieTracking *tracking, ImBuf *ibuf, int width, int height, float overscan)
-{
-	MovieTrackingCamera *camera = &tracking->camera;
-
-	if (camera->intrinsics == NULL)
-		camera->intrinsics = BKE_tracking_distortion_create();
-
-	return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, width, height, overscan, 1);
-}
-
-ImBuf *BKE_tracking_distort(MovieTracking *tracking, ImBuf *ibuf, int width, int height, float overscan)
-{
-	MovieTrackingCamera *camera = &tracking->camera;
-
-	if (camera->intrinsics == NULL)
-		camera->intrinsics = BKE_tracking_distortion_create();
-
-	return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, width, height, overscan, 0);
-}
-
-/* area - which part of marker should be selected. see TRACK_AREA_* constants */
-void BKE_tracking_select_track(ListBase *tracksbase, MovieTrackingTrack *track, int area, int extend)
-{
-	if (extend) {
-		BKE_tracking_track_flag(track, area, SELECT, 0);
-	}
-	else {
-		MovieTrackingTrack *cur = tracksbase->first;
-
-		while (cur) {
-			if ((cur->flag & TRACK_HIDDEN) == 0) {
-				if (cur == track) {
-					BKE_tracking_track_flag(cur, TRACK_AREA_ALL, SELECT, 1);
-					BKE_tracking_track_flag(cur, area, SELECT, 0);
-				}
-				else {
-					BKE_tracking_track_flag(cur, TRACK_AREA_ALL, SELECT, 1);
-				}
-			}
-
-			cur = cur->next;
-		}
-	}
-}
-
-void BKE_tracking_deselect_track(MovieTrackingTrack *track, int area)
-{
-	BKE_tracking_track_flag(track, area, SELECT, 1);
-}
-
-MovieTrackingObject *BKE_tracking_new_object(MovieTracking *tracking, const char *name)
-{
-	MovieTrackingObject *object = MEM_callocN(sizeof(MovieTrackingObject), "tracking object");
-
-	if (tracking->tot_object == 0) {
-		/* first object is always camera */
-		BLI_strncpy(object->name, "Camera", sizeof(object->name));
-
-		object->flag |= TRACKING_OBJECT_CAMERA;
-	}
-	else {
-		BLI_strncpy(object->name, name, sizeof(object->name));
-	}
-
-	BLI_addtail(&tracking->objects, object);
-
-	tracking->tot_object++;
-	tracking->objectnr = BLI_countlist(&tracking->objects) - 1;
-
-	object->scale = 1.0f;
-
-	BKE_tracking_object_unique_name(tracking, object);
-
-	return object;
-}
-
-void BKE_tracking_remove_object(MovieTracking *tracking, MovieTrackingObject *object)
-{
-	MovieTrackingTrack *track;
-	int index = BLI_findindex(&tracking->objects, object);
-
-	if (index < 0)
-		return;
-
-	if (object->flag & TRACKING_OBJECT_CAMERA) {
-		/* object used for camera solving can't be deleted */
-		return;
-	}
-
-	track = object->tracks.first;
-	while (track) {
-		if (track == tracking->act_track)
-			tracking->act_track = NULL;
-
-		track = track->next;
-	}
-
-	tracking_object_free(object);
-	BLI_freelinkN(&tracking->objects, object);
-
-	tracking->tot_object--;
-
-	if (index > 0)
-		tracking->objectnr = index - 1;
-	else
-		tracking->objectnr = 0;
-}
-
-void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *object)
-{
-	BLI_uniquename(&tracking->objects, object, "Object", '.',
-	               offsetof(MovieTrackingObject, name), sizeof(object->name));
-}
-
-MovieTrackingObject *BKE_tracking_named_object(MovieTracking *tracking, const char *name)
-{
-	MovieTrackingObject *object = tracking->objects.first;
-
-	while (object) {
-		if (!strcmp(object->name, name))
-			return object;
-
-		object = object->next;
-	}
-
-	return NULL;
-}
-
-/*********************** dopesheet functions *************************/
+/*********************** Dopesheet functions *************************/
 
 static int channels_alpha_sort(void *a, void *b)
 {
@@ -3586,11 +3670,11 @@ void BKE_tracking_dopesheet_tag_update(MovieTracking *tracking)
 
 void BKE_tracking_dopesheet_update(MovieTracking *tracking)
 {
-	MovieTrackingObject *object = BKE_tracking_active_object(tracking);
+	MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
 	MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
 	MovieTrackingTrack *track;
 	MovieTrackingReconstruction *reconstruction;
-	ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
+	ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
 
 	short sort_method = dopesheet->sort_method;
 	short inverse = dopesheet->flag & TRACKING_DOPE_SORT_INVERSE;
@@ -3602,7 +3686,7 @@ void BKE_tracking_dopesheet_update(MovieTracking *tracking)
 
 	tracking_dopesheet_free(dopesheet);
 
-	reconstruction = BKE_tracking_object_reconstruction(tracking, object);
+	reconstruction = BKE_tracking_object_get_reconstruction(tracking, object);
 
 	for (track = tracksbase->first; track; track = track->next) {
 		MovieTrackingDopesheetChannel *channel;