Code style cleaup for motion-tracking modules.
authorSergey Sharybin <sergey.vfx@gmail.com>
Sun, 25 Mar 2012 23:19:21 +0000 (23:19 +0000)
committerSergey Sharybin <sergey.vfx@gmail.com>
Sun, 25 Mar 2012 23:19:21 +0000 (23:19 +0000)
Should be no functional changes.

19 files changed:
source/blender/blenkernel/BKE_movieclip.h
source/blender/blenkernel/BKE_tracking.h
source/blender/blenkernel/intern/constraint.c
source/blender/blenkernel/intern/movieclip.c
source/blender/blenkernel/intern/tracking.c
source/blender/editors/space_clip/clip_buttons.c
source/blender/editors/space_clip/clip_draw.c
source/blender/editors/space_clip/clip_editor.c
source/blender/editors/space_clip/clip_graph_draw.c
source/blender/editors/space_clip/clip_graph_ops.c
source/blender/editors/space_clip/clip_intern.h
source/blender/editors/space_clip/clip_ops.c
source/blender/editors/space_clip/clip_toolbar.c
source/blender/editors/space_clip/clip_utils.c
source/blender/editors/space_clip/space_clip.c
source/blender/editors/space_clip/tracking_ops.c
source/blender/editors/transform/transform.c
source/blender/editors/transform/transform_conversions.c
source/blender/editors/transform/transform_generics.c

index 27b377d8cd521d51430670c3c2342554623e3882..d7b2f271a837321da57acfaef6729113900ca67d 100644 (file)
@@ -61,7 +61,7 @@ void BKE_movieclip_update_scopes(struct MovieClip *clip, struct MovieClipUser *u
 void BKE_movieclip_get_cache_segments(struct MovieClip *clip, struct MovieClipUser *user, int *totseg_r, int **points_r);
 
 void BKE_movieclip_build_proxy_frame(struct MovieClip *clip, int clip_flag, struct MovieDistortion *distortion,
-                       int cfra, int *build_sizes, int build_count, int undistorted);
+                                     int cfra, int *build_sizes, int build_count, int undistorted);
 
 /* cacheing flags */
 #define MOVIECLIP_CACHE_SKIP        (1<<0)
index b853a5b4af981b584109342edb426dbb08e5d5b4..2bb8fc691f055c03d0a422fc32096246b4ee8f27 100644 (file)
@@ -52,9 +52,9 @@ void BKE_tracking_clamp_track(struct MovieTrackingTrack *track, int event);
 void BKE_tracking_track_flag(struct MovieTrackingTrack *track, int area, int flag, int clear);
 
 struct MovieTrackingTrack *BKE_tracking_add_track(struct MovieTracking *tracking, struct ListBase *tracksbase,
-                       float x, float y, int framenr, int width, int height);
+                                                  float x, float y, int framenr, int width, int height);
 struct MovieTrackingMarker *BKE_tracking_insert_marker(struct MovieTrackingTrack *track,
-                       struct MovieTrackingMarker *marker);
+                                                       struct MovieTrackingMarker *marker);
 void BKE_tracking_delete_marker(struct MovieTrackingTrack *track, int framenr);
 
 struct MovieTrackingMarker *BKE_tracking_get_marker(struct MovieTrackingTrack *track, int framenr);
@@ -71,9 +71,11 @@ void BKE_tracking_join_tracks(struct MovieTrackingTrack *dst_track, struct Movie
 void BKE_tracking_free(struct MovieTracking *tracking);
 
 struct ImBuf *BKE_tracking_get_pattern_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
-                       struct MovieTrackingMarker *marker, int margin, int anchored, float pos[2], int origin[2]);
+                                             struct MovieTrackingMarker *marker, int margin, int anchored,
+                                             float pos[2], int origin[2]);
 struct ImBuf *BKE_tracking_get_search_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
-                       struct MovieTrackingMarker *marker, int margin, int anchored, float pos[2], int origin[2]);
+                                            struct MovieTrackingMarker *marker, int margin, int anchored,
+                                            float pos[2], int origin[2]);
 
 void BKE_track_unique_name(struct ListBase *tracksbase, struct MovieTrackingTrack *track);
 
@@ -85,7 +87,7 @@ void BKE_tracking_camera_to_blender(struct MovieTracking *tracking, struct Scene
 
 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]);
+                                    int framenr, int winx, int winy, float mat[4][4]);
 
 struct ListBase *BKE_tracking_get_tracks(struct MovieTracking *tracking);
 struct MovieTrackingReconstruction *BKE_tracking_get_reconstruction(struct MovieTracking *tracking);
@@ -95,7 +97,7 @@ struct MovieTrackingObject *BKE_tracking_active_object(struct MovieTracking *tra
 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 MovieTrackingObject *object);
 
 void BKE_tracking_disable_imbuf_channels(struct ImBuf *ibuf, int disable_red, int disable_green, int disable_blue, int grayscale);
 
@@ -115,24 +117,24 @@ int BKE_tracking_next(struct MovieTrackingContext *context);
 
 /* Camera solving */
 int BKE_tracking_can_reconstruct(struct MovieTracking *tracking, struct MovieTrackingObject *object,
-                       char *error_msg, int error_size);
+                                 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);
 void BKE_tracking_reconstruction_context_free(struct MovieReconstructContext *context);
-void BKE_tracking_solve_reconstruction(struct MovieReconstructContext *context,
-                       short *stop, short *do_update, float *progress, char *stats_message, int message_size);
+void BKE_tracking_solve_reconstruction(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]);
+void BKE_tracking_get_interpolated_camera(struct MovieTracking *tracking, struct MovieTrackingObject *object,
+                                          int framenr, float mat[4][4]);
 
 /* 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);
+                              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);
@@ -146,7 +148,7 @@ void BKE_tracking_invert_intrinsics(struct MovieTracking *tracking, float co[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);
+                                           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);
index 449376a3960bca65be5411eac7e543e6b6572311..0126f1dc416ac339a3b7ee8c5a6f461ba7f611a8 100644 (file)
@@ -3927,28 +3927,28 @@ static bConstraintTypeInfo CTI_PIVOT = {
 
 /* ----------- Follow Track ------------- */
 
-static void followtrack_new_data (void *cdata)
+static void followtrack_new_data(void *cdata)
 {
-       bFollowTrackConstraint *data= (bFollowTrackConstraint *)cdata;
-       
-       data->clip= NULL;
+       bFollowTrackConstraint *data = (bFollowTrackConstraint *)cdata;
+
+       data->clip = NULL;
        data->flag |= FOLLOWTRACK_ACTIVECLIP;
 }
 
-static void followtrack_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata)
+static void followtrack_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
 {
-       bFollowTrackConstraint *data= con->data;
-       
+       bFollowTrackConstraint *data = con->data;
+
        func(con, (ID**)&data->clip, userdata);
        func(con, (ID**)&data->camera, userdata);
        func(con, (ID**)&data->depth_ob, userdata);
 }
 
-static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
+static void followtrack_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
 {
-       Scene *scene= cob->scene;
-       bFollowTrackConstraint *data= con->data;
-       MovieClip *clip= data->clip;
+       Scene *scene = cob->scene;
+       bFollowTrackConstraint *data = con->data;
+       MovieClip *clip = data->clip;
        MovieTracking *tracking;
        MovieTrackingTrack *track;
        MovieTrackingObject *tracking_object;
@@ -3960,17 +3960,17 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
        if (!clip || !data->track[0] || !camob)
                return;
 
-       tracking= &clip->tracking;
+       tracking = &clip->tracking;
 
        if (data->object[0])
-               tracking_object= BKE_tracking_named_object(tracking, data->object);
+               tracking_object = BKE_tracking_named_object(tracking, data->object);
        else
-               tracking_object= BKE_tracking_get_camera_object(tracking);
+               tracking_object = BKE_tracking_get_camera_object(tracking);
 
        if (!tracking_object)
                return;
 
-       track= BKE_tracking_named_track(tracking, tracking_object, data->track);
+       track = BKE_tracking_named_track(tracking, tracking_object, data->track);
 
        if (!track)
                return;
@@ -3981,7 +3981,7 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
 
                        copy_m4_m4(obmat, cob->matrix);
 
-                       if ((tracking_object->flag&TRACKING_OBJECT_CAMERA)==0) {
+                       if ((tracking_object->flag & TRACKING_OBJECT_CAMERA)==0) {
                                float imat[4][4];
 
                                copy_m4_m4(mat, camob->obmat);
@@ -4003,15 +4003,15 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
        else {
                MovieTrackingMarker *marker;
                float vec[3], disp[3], axis[3], mat[4][4];
-               float aspect= (scene->r.xsch*scene->r.xasp) / (scene->r.ysch*scene->r.yasp);
+               float aspect= (scene->r.xsch * scene->r.xasp) / (scene->r.ysch * scene->r.yasp);
                float len, d;
 
                where_is_object_mat(scene, camob, mat);
 
                /* camera axis */
-               vec[0]= 0.0f;
-               vec[1]= 0.0f;
-               vec[2]= 1.0f;
+               vec[0] = 0.0f;
+               vec[1] = 0.0f;
+               vec[2] = 1.0f;
                mul_v3_m4v3(axis, mat, vec);
 
                /* distance to projection plane */
@@ -4019,13 +4019,13 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
                sub_v3_v3(vec, mat[3]);
                project_v3_v3v3(disp, vec, axis);
 
-               len= len_v3(disp);
+               len = len_v3(disp);
 
                if (len > FLT_EPSILON) {
                        CameraParams params;
                        float pos[2], rmat[4][4];
 
-                       marker= BKE_tracking_get_marker(track, scene->r.cfra);
+                       marker = BKE_tracking_get_marker(track, scene->r.cfra);
 
                        add_v2_v2v2(pos, marker->pos, track->offset);
 
@@ -4033,12 +4033,14 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
                        camera_params_from_object(&params, camob);
 
                        if (params.is_ortho) {
-                               vec[0]= params.ortho_scale * (pos[0]-0.5f+params.shiftx);
-                               vec[1]= params.ortho_scale * (pos[1]-0.5f+params.shifty);
-                               vec[2]= -len;
+                               vec[0] = params.ortho_scale * (pos[0] - 0.5f + params.shiftx);
+                               vec[1] = params.ortho_scale * (pos[1] - 0.5f + params.shifty);
+                               vec[2] = -len;
 
-                               if (aspect > 1.0f) vec[1] /= aspect;
-                               else vec[0] *= aspect;
+                               if (aspect > 1.0f)
+                                       vec[1] /= aspect;
+                               else
+                                       vec[0] *= aspect;
 
                                mul_v3_m4v3(disp, camob->obmat, vec);
 
@@ -4049,14 +4051,16 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
                                copy_v3_v3(cob->matrix[3], disp);
                        }
                        else {
-                               d= (len*params.sensor_x) / (2.0f*params.lens);
+                               d=  (len * params.sensor_x) / (2.0f * params.lens);
 
-                               vec[0]= d*(2.0f*(pos[0]+params.shiftx)-1.0f);
-                               vec[1]= d*(2.0f*(pos[1]+params.shifty)-1.0f);
-                               vec[2]= -len;
+                               vec[0] = d * (2.0f * (pos[0] + params.shiftx) - 1.0f);
+                               vec[1] = d * (2.0f * (pos[1] + params.shifty) - 1.0f);
+                               vec[2] = -len;
 
-                               if (aspect > 1.0f) vec[1] /= aspect;
-                               else vec[0] *= aspect;
+                               if (aspect > 1.0f)
+                                       vec[1] /= aspect;
+                               else
+                                       vec[0] *= aspect;
 
                                mul_v3_m4v3(disp, camob->obmat, vec);
 
@@ -4069,8 +4073,8 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
                        }
 
                        if (data->depth_ob && data->depth_ob->derivedFinal) {
-                               Object *depth_ob= data->depth_ob;
-                               BVHTreeFromMesh treeData= NULL_BVHTreeFromMesh;
+                               Object *depth_ob = data->depth_ob;
+                               BVHTreeFromMesh treeData = NULL_BVHTreeFromMesh;
                                BVHTreeRayHit hit;
                                float ray_start[3], ray_end[3], ray_nor[3], imat[4][4];
                                int result;
@@ -4084,10 +4088,10 @@ static void followtrack_evaluate (bConstraint *con, bConstraintOb *cob, ListBase
 
                                bvhtree_from_mesh_faces(&treeData, depth_ob->derivedFinal, 0.0f, 4, 6);
 
-                               hit.dist= FLT_MAX;
-                               hit.index= -1;
+                               hit.dist = FLT_MAX;
+                               hit.index = -1;
 
-                               result= BLI_bvhtree_ray_cast(treeData.tree, ray_start, ray_nor, 0.0f, &hit, treeData.raycast_callback, &treeData);
+                               result = BLI_bvhtree_ray_cast(treeData.tree, ray_start, ray_nor, 0.0f, &hit, treeData.raycast_callback, &treeData);
 
                                if (result != -1) {
                                        mul_v3_m4v3(cob->matrix[3], depth_ob->obmat, hit.co);
@@ -4117,34 +4121,34 @@ static bConstraintTypeInfo CTI_FOLLOWTRACK = {
 
 /* ----------- Camre Solver ------------- */
 
-static void camerasolver_new_data (void *cdata)
+static void camerasolver_new_data(void *cdata)
 {
-       bCameraSolverConstraint *data= (bCameraSolverConstraint *)cdata;
-       
+       bCameraSolverConstraint *data = (bCameraSolverConstraint *)cdata;
+
        data->clip = NULL;
        data->flag |= CAMERASOLVER_ACTIVECLIP;
 }
 
-static void camerasolver_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata)
+static void camerasolver_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
 {
-       bCameraSolverConstraint *data= con->data;
-       
+       bCameraSolverConstraint *data = con->data;
+
        func(con, (ID**)&data->clip, userdata);
 }
 
-static void camerasolver_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
+static void camerasolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
 {
-       Scene *scene= cob->scene;
-       bCameraSolverConstraint *data= con->data;
-       MovieClip *clip= data->clip;
+       Scene *scene = cob->scene;
+       bCameraSolverConstraint *data = con->data;
+       MovieClip *clip = data->clip;
 
        if (data->flag & CAMERASOLVER_ACTIVECLIP)
-               clip= scene->clip;
+               clip = scene->clip;
 
        if (clip) {
                float mat[4][4], obmat[4][4];
-               MovieTracking *tracking= &clip->tracking;
-               MovieTrackingObject *object= BKE_tracking_get_camera_object(tracking);
+               MovieTracking *tracking = &clip->tracking;
+               MovieTrackingObject *object = BKE_tracking_get_camera_object(tracking);
 
                BKE_tracking_get_interpolated_camera(tracking, object, scene->r.cfra, mat);
 
@@ -4172,16 +4176,16 @@ static bConstraintTypeInfo CTI_CAMERASOLVER = {
 
 /* ----------- Object Solver ------------- */
 
-static void objectsolver_new_data (void *cdata)
+static void objectsolver_new_data(void *cdata)
 {
-       bObjectSolverConstraint *data= (bObjectSolverConstraint *)cdata;
+       bObjectSolverConstraint *data = (bObjectSolverConstraint *)cdata;
 
        data->clip = NULL;
        data->flag |= OBJECTSOLVER_ACTIVECLIP;
        unit_m4(data->invmat);
 }
 
-static void objectsolver_id_looper (bConstraint *con, ConstraintIDFunc func, void *userdata)
+static void objectsolver_id_looper(bConstraint *con, ConstraintIDFunc func, void *userdata)
 {
        bObjectSolverConstraint *data= con->data;
 
@@ -4189,12 +4193,12 @@ static void objectsolver_id_looper (bConstraint *con, ConstraintIDFunc func, voi
        func(con, (ID**)&data->camera, userdata);
 }
 
-static void objectsolver_evaluate (bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
+static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase *UNUSED(targets))
 {
-       Scene *scene= cob->scene;
-       bObjectSolverConstraint *data= con->data;
-       MovieClip *clip= data->clip;
-       Object *camob= data->camera ? data->camera : scene->camera;
+       Scene *scene = cob->scene;
+       bObjectSolverConstraint *data = con->data;
+       MovieClip *clip = data->clip;
+       Object *camob = data->camera ? data->camera : scene->camera;
 
        if (data->flag & OBJECTSOLVER_ACTIVECLIP)
                clip= scene->clip;
@@ -4203,10 +4207,10 @@ static void objectsolver_evaluate (bConstraint *con, bConstraintOb *cob, ListBas
                return;
 
        if (clip) {
-               MovieTracking *tracking= &clip->tracking;
+               MovieTracking *tracking = &clip->tracking;
                MovieTrackingObject *object;
 
-               object= BKE_tracking_named_object(tracking, data->object);
+               object = BKE_tracking_named_object(tracking, data->object);
 
                if (object) {
                        float mat[4][4], obmat[4][4], imat[4][4], cammat[4][4], camimat[4][4], parmat[4][4];
index 0cecc09a9d7a34754b6eb5bf58ec91ac170025ac..bc147c52094952a8d54dd645c5a277f17a8de565 100644 (file)
 
 static int sequence_guess_offset(const char *full_name, int head_len, int numlen)
 {
-       char num[FILE_MAX]= {0};
+       char num[FILE_MAX] = {0};
 
-       BLI_strncpy(num, full_name+head_len, numlen+1);
+       BLI_strncpy(num, full_name + head_len, numlen + 1);
 
        return atoi(num);
 }
 
 static int rendersize_to_proxy(MovieClipUser *user, int flag)
 {
-       if ((flag&MCLIP_USE_PROXY)==0)
+       if ((flag & MCLIP_USE_PROXY) == 0)
                return IMB_PROXY_NONE;
 
-       switch(user->render_size) {
+       switch (user->render_size) {
                case MCLIP_PROXY_RENDER_SIZE_25:
                        return IMB_PROXY_25;
 
@@ -116,7 +116,7 @@ static int rendersize_to_proxy(MovieClipUser *user, int flag)
 
 static int rendersize_to_number(int render_size)
 {
-       switch(render_size) {
+       switch (render_size) {
                case MCLIP_PROXY_RENDER_SIZE_25:
                        return 25;
 
@@ -138,7 +138,7 @@ static int rendersize_to_number(int render_size)
 
 static int get_timecode(MovieClip *clip, int flag)
 {
-       if ((flag&MCLIP_USE_PROXY)==0)
+       if ((flag & MCLIP_USE_PROXY) == 0)
                return IMB_TC_NONE;
 
        return clip->proxy.tc;
@@ -157,8 +157,10 @@ static void get_sequence_fname(MovieClip *clip, int framenr, char *name)
         * autoguess offset for now. could be something smarter in the future */
        offset= sequence_guess_offset(clip->name, strlen(head), numlen);
 
-       if (numlen) BLI_stringenc(name, head, tail, numlen, offset+framenr-1);
-       else        BLI_strncpy(name, clip->name, sizeof(clip->name));
+       if (numlen)
+               BLI_stringenc(name, head, tail, numlen, offset + framenr - 1);
+       else
+               BLI_strncpy(name, clip->name, sizeof(clip->name));
 
        BLI_path_abs(name, ID_BLEND_PATH(G.main, &clip->id));
 }
@@ -166,12 +168,12 @@ static void get_sequence_fname(MovieClip *clip, int framenr, char *name)
 /* supposed to work with sequences only */
 static void get_proxy_fname(MovieClip *clip, int proxy_render_size, int undistorted, int framenr, char *name)
 {
-       int size= rendersize_to_number(proxy_render_size);
+       int size = rendersize_to_number(proxy_render_size);
        char dir[FILE_MAX], clipdir[FILE_MAX], clipfile[FILE_MAX];
 
        BLI_split_dirfile(clip->name, clipdir, clipfile, FILE_MAX, FILE_MAX);
 
-       if (clip->flag&MCLIP_USE_PROXY_CUSTOM_DIR) {
+       if (clip->flag & MCLIP_USE_PROXY_CUSTOM_DIR) {
                BLI_strncpy(dir, clip->proxy.dir, sizeof(dir));
        }
        else {
@@ -195,27 +197,27 @@ static ImBuf *movieclip_load_sequence_file(MovieClip *clip, MovieClipUser *user,
        char name[FILE_MAX];
        int loadflag, use_proxy= 0;
 
-       use_proxy= (flag&MCLIP_USE_PROXY) && user->render_size != MCLIP_PROXY_RENDER_SIZE_FULL;
+       use_proxy = (flag & MCLIP_USE_PROXY) && user->render_size != MCLIP_PROXY_RENDER_SIZE_FULL;
        if (use_proxy) {
-               int undistort= user->render_flag&MCLIP_PROXY_RENDER_UNDISTORT;
+               int undistort = user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT;
                get_proxy_fname(clip, user->render_size, undistort, framenr, name);
        }
        else
                get_sequence_fname(clip, framenr, name);
 
-       loadflag= IB_rect|IB_multilayer;
+       loadflag = IB_rect|IB_multilayer;
 
        /* read ibuf */
-       ibuf= IMB_loadiffname(name, loadflag);
+       ibuf = IMB_loadiffname(name, loadflag);
 
        return ibuf;
 }
 
 static ImBuf *movieclip_load_movie_file(MovieClip *clip, MovieClipUser *user, int framenr, int flag)
 {
-       ImBuf *ibuf= NULL;
-       int tc= get_timecode(clip, flag);
-       int proxy= rendersize_to_proxy(user, flag);
+       ImBuf *ibuf = NULL;
+       int tc = get_timecode(clip, flag);
+       int proxy = rendersize_to_proxy(user, flag);
        char str[FILE_MAX];
 
        if (!clip->anim) {
@@ -223,10 +225,10 @@ static ImBuf *movieclip_load_movie_file(MovieClip *clip, MovieClipUser *user, in
                BLI_path_abs(str, ID_BLEND_PATH(G.main, &clip->id));
 
                /* FIXME: make several stream accessible in image editor, too */
-               clip->anim= openanim(str, IB_rect, 0);
+               clip->anim = openanim(str, IB_rect, 0);
 
                if (clip->anim) {
-                       if (clip->flag&MCLIP_USE_PROXY_CUSTOM_DIR) {
+                       if (clip->flag & MCLIP_USE_PROXY_CUSTOM_DIR) {
                                char dir[FILE_MAX];
                                BLI_strncpy(dir, clip->proxy.dir, sizeof(dir));
                                BLI_path_abs(dir, G.main->name);
@@ -239,16 +241,16 @@ static ImBuf *movieclip_load_movie_file(MovieClip *clip, MovieClipUser *user, in
                int dur;
                int fra;
 
-               dur= IMB_anim_get_duration(clip->anim, tc);
-               fra= framenr-1;
+               dur = IMB_anim_get_duration(clip->anim, tc);
+               fra = framenr - 1;
 
                if (fra<0)
-                       fra= 0;
+                       fra = 0;
 
-               if (fra>(dur-1))
-                       fra= dur-1;
+               if (fra > (dur - 1))
+                       fra = dur - 1;
 
-               ibuf= IMB_anim_absolute(clip->anim, fra, tc, proxy);
+               ibuf = IMB_anim_absolute(clip->anim, fra, tc, proxy);
        }
 
        return ibuf;
@@ -295,34 +297,40 @@ typedef struct MovieClipImBufCacheKey {
 
 static void moviecache_keydata(void *userkey, int *framenr, int *proxy, int *render_flags)
 {
-       MovieClipImBufCacheKey *key= (MovieClipImBufCacheKey*)userkey;
+       MovieClipImBufCacheKey *key = (MovieClipImBufCacheKey*)userkey;
 
-       *framenr= key->framenr;
-       *proxy= key->proxy;
-       *render_flags= key->render_flag;
+       *framenr = key->framenr;
+       *proxy = key->proxy;
+       *render_flags = key->render_flag;
 }
 
 static unsigned int moviecache_hashhash(const void *keyv)
 {
-       MovieClipImBufCacheKey *key= (MovieClipImBufCacheKey*)keyv;
-       int rval= key->framenr;
+       MovieClipImBufCacheKey *key = (MovieClipImBufCacheKey*)keyv;
+       int rval = key->framenr;
 
        return rval;
 }
 
 static int moviecache_hashcmp(const void *av, const void *bv)
 {
-       const MovieClipImBufCacheKey *a= (MovieClipImBufCacheKey*)av;
-       const MovieClipImBufCacheKey *b= (MovieClipImBufCacheKey*)bv;
+       const MovieClipImBufCacheKey *a = (MovieClipImBufCacheKey*)av;
+       const MovieClipImBufCacheKey *b = (MovieClipImBufCacheKey*)bv;
 
-       if (a->framenr<b->framenr) return -1;
-       else if (a->framenr>b->framenr) return 1;
+       if (a->framenr < b->framenr)
+               return -1;
+       else if (a->framenr > b->framenr)
+               return 1;
 
-       if (a->proxy<b->proxy) return -1;
-       else if (a->proxy>b->proxy) return 1;
+       if (a->proxy < b->proxy)
+               return -1;
+       else if (a->proxy > b->proxy)
+               return 1;
 
-       if (a->render_flag<b->render_flag) return -1;
-       else if (a->render_flag>b->render_flag) return 1;
+       if (a->render_flag < b->render_flag)
+               return -1;
+       else if (a->render_flag > b->render_flag)
+               return 1;
 
        return 0;
 }
@@ -332,15 +340,15 @@ static ImBuf *get_imbuf_cache(MovieClip *clip, MovieClipUser *user, int flag)
        if (clip->cache) {
                MovieClipImBufCacheKey key;
 
-               key.framenr= user->framenr;
+               key.framenr = user->framenr;
 
-               if (flag&MCLIP_USE_PROXY) {
-                       key.proxy= rendersize_to_proxy(user, flag);
-                       key.render_flag= user->render_flag;
+               if (flag & MCLIP_USE_PROXY) {
+                       key.proxy = rendersize_to_proxy(user, flag);
+                       key.render_flag = user->render_flag;
                }
                else {
-                       key.proxy= IMB_PROXY_NONE;
-                       key.render_flag= 0;
+                       key.proxy = IMB_PROXY_NONE;
+                       key.render_flag = 0;
                }
 
                return IMB_moviecache_get(clip->cache->moviecache, &key);
@@ -354,21 +362,21 @@ static void put_imbuf_cache(MovieClip *clip, MovieClipUser *user, ImBuf *ibuf, i
        MovieClipImBufCacheKey key;
 
        if (!clip->cache) {
-               clip->cache= MEM_callocN(sizeof(MovieClipCache), "movieClipCache");
+               clip->cache = MEM_callocN(sizeof(MovieClipCache), "movieClipCache");
 
-               clip->cache->moviecache= IMB_moviecache_create(sizeof(MovieClipImBufCacheKey), moviecache_hashhash,
+               clip->cache->moviecache = IMB_moviecache_create(sizeof(MovieClipImBufCacheKey), moviecache_hashhash,
                                moviecache_hashcmp, moviecache_keydata);
        }
 
-       key.framenr= user->framenr;
+       key.framenr = user->framenr;
 
-       if (flag&MCLIP_USE_PROXY) {
-               key.proxy= rendersize_to_proxy(user, flag);
-               key.render_flag= user->render_flag;
+       if (flag & MCLIP_USE_PROXY) {
+               key.proxy = rendersize_to_proxy(user, flag);
+               key.render_flag = user->render_flag;
        }
        else {
-               key.proxy= IMB_PROXY_NONE;
-               key.render_flag= 0;
+               key.proxy = IMB_PROXY_NONE;
+               key.render_flag = 0;
        }
 
        IMB_moviecache_put(clip->cache->moviecache, &key, ibuf);
@@ -381,18 +389,18 @@ static MovieClip *movieclip_alloc(const char *name)
 {
        MovieClip *clip;
 
-       clip= alloc_libblock(&G.main->movieclip, ID_MC, name);
+       clip = alloc_libblock(&G.main->movieclip, ID_MC, name);
 
-       clip->aspx= clip->aspy= 1.0f;
+       clip->aspx = clip->aspy= 1.0f;
 
        BKE_tracking_init_settings(&clip->tracking);
 
-       clip->proxy.build_size_flag= IMB_PROXY_25;
-       clip->proxy.build_tc_flag= IMB_TC_RECORD_RUN |
-                                  IMB_TC_FREE_RUN |
-                                  IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN |
-                                  IMB_TC_RECORD_RUN_NO_GAPS;
-       clip->proxy.quality= 90;
+       clip->proxy.build_size_flag = IMB_PROXY_25;
+       clip->proxy.build_tc_flag = IMB_TC_RECORD_RUN |
+                                   IMB_TC_FREE_RUN |
+                                   IMB_TC_INTERPOLATED_REC_DATE_FREE_RUN |
+                                   IMB_TC_RECORD_RUN_NO_GAPS;
+       clip->proxy.quality = 90;
 
        return clip;
 }
@@ -413,16 +421,17 @@ MovieClip *BKE_add_movieclip_file(const char *name)
        BLI_path_abs(str, G.main->name);
 
        /* exists? */
-       file= BLI_open(str, O_BINARY|O_RDONLY,0);
-       if (file== -1) return NULL;
+       file = BLI_open(str, O_BINARY|O_RDONLY,0);
+       if (file == -1)
+               return NULL;
        close(file);
 
        /* ** first search an identical clip ** */
-       for (clip= G.main->movieclip.first; clip; clip= clip->id.next) {
+       for (clip = G.main->movieclip.first; clip; clip = clip->id.next) {
                BLI_strncpy(strtest, clip->name, sizeof(clip->name));
                BLI_path_abs(strtest, G.main->name);
 
-               if (strcmp(strtest, str)==0) {
+               if (strcmp(strtest, str) == 0) {
                        BLI_strncpy(clip->name, name, sizeof(clip->name));  /* for stringcode */
                        clip->id.us++;  /* officially should not, it doesn't link here! */
 
@@ -433,24 +442,27 @@ MovieClip *BKE_add_movieclip_file(const char *name)
        /* ** add new movieclip ** */
 
        /* create a short library name */
-       len= strlen(name);
+       len = strlen(name);
 
-       while (len > 0 && name[len - 1] != '/' && name[len - 1] != '\\') len--;
-       libname= name+len;
+       while (len > 0 && name[len - 1] != '/' && name[len - 1] != '\\')
+               len--;
+       libname = name + len;
 
-       clip= movieclip_alloc(libname);
+       clip = movieclip_alloc(libname);
        BLI_strncpy(clip->name, name, sizeof(clip->name));
 
-       if (BLI_testextensie_array(name, imb_ext_movie)) clip->source= MCLIP_SRC_MOVIE;
-       else clip->source= MCLIP_SRC_SEQUENCE;
+       if (BLI_testextensie_array(name, imb_ext_movie))
+               clip->source= MCLIP_SRC_MOVIE;
+       else
+               clip->source= MCLIP_SRC_SEQUENCE;
 
-       user.framenr= 1;
+       user.framenr = 1;
        BKE_movieclip_get_size(clip, &user, &width, &height);
        if (width && height) {
-               clip->tracking.camera.principal[0]= ((float)width)/2;
-               clip->tracking.camera.principal[1]= ((float)height)/2;
+               clip->tracking.camera.principal[0] = ((float)width) / 2.0f;
+               clip->tracking.camera.principal[1] = ((float)height) / 2.0f;
 
-               clip->tracking.camera.focal= 24.0f*width/clip->tracking.camera.sensor_width;
+               clip->tracking.camera.focal = 24.0f * width / clip->tracking.camera.sensor_width;
        }
 
        return clip;
@@ -458,24 +470,24 @@ MovieClip *BKE_add_movieclip_file(const char *name)
 
 static void real_ibuf_size(MovieClip *clip, MovieClipUser *user, ImBuf *ibuf, int *width, int *height)
 {
-       *width= ibuf->x;
-       *height= ibuf->y;
+       *width = ibuf->x;
+       *height = ibuf->y;
 
-       if (clip->flag&MCLIP_USE_PROXY) {
+       if (clip->flag & MCLIP_USE_PROXY) {
                switch(user->render_size) {
                        case MCLIP_PROXY_RENDER_SIZE_25:
-                               (*width)*= 4;
-                               (*height)*= 4;
+                               (*width) *= 4;
+                               (*height) *= 4;
                                break;
 
                        case MCLIP_PROXY_RENDER_SIZE_50:
-                               (*width)*= 2.0f;
-                               (*height)*= 2.0f;
+                               (*width) *= 2.0f;
+                               (*height) *= 2.0f;
                                break;
 
                        case MCLIP_PROXY_RENDER_SIZE_75:
-                               *width= ((float)*width)*4.0f/3.0f;
-                               *height= ((float)*height)*4.0f/3.0f;
+                               *width = ((float)*width)*4.0f/3.0f;
+                               *height = ((float)*height)*4.0f/3.0f;
                                break;
                }
        }
@@ -490,12 +502,12 @@ static ImBuf *get_undistorted_ibuf(MovieClip *clip, struct MovieDistortion *dist
        imb_freerectfloatImBuf(ibuf);
 
        if (distortion)
-               undistibuf= BKE_tracking_distortion_exec(distortion, &clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f, 1);
+               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(&clip->tracking, ibuf, ibuf->x, ibuf->y, 0.0f);
 
-       if (undistibuf->userflags&IB_RECT_INVALID) {
-               ibuf->userflags&= ~IB_RECT_INVALID;
+       if (undistibuf->userflags & IB_RECT_INVALID) {
+               ibuf->userflags &= ~IB_RECT_INVALID;
                IMB_rect_from_float(undistibuf);
        }
 
@@ -528,29 +540,29 @@ static int need_postprocessed_frame(MovieClipUser *user, int flag, int postproce
 
 static int check_undistortion_cache_flags(MovieClip *clip)
 {
-       MovieClipCache *cache= clip->cache;
-       MovieTrackingCamera *camera= &clip->tracking.camera;
+       MovieClipCache *cache = clip->cache;
+       MovieTrackingCamera *camera = &clip->tracking.camera;
 
        /* check for distortion model changes */
        if (!equals_v2v2(camera->principal, cache->postprocessed.principal))
-               return 0;
+               return FALSE;
 
        if (!equals_v3v3(&camera->k1, &cache->postprocessed.k1))
-               return 0;
+               return FALSE;
 
-       return 1;
+       return TRUE;
 }
 
 static ImBuf *get_postprocessed_cached_frame(MovieClip *clip, MovieClipUser *user, int flag, int postprocess_flag)
 {
-       MovieClipCache *cache= clip->cache;
-       int framenr= user->framenr;
-       short proxy= IMB_PROXY_NONE;
-       int render_flag= 0;
-
-       if (flag&MCLIP_USE_PROXY) {
-               proxy= rendersize_to_proxy(user, flag);
-               render_flag= user->render_flag;
+       MovieClipCache *cache = clip->cache;
+       int framenr = user->framenr;
+       short proxy = IMB_PROXY_NONE;
+       int render_flag = 0;
+
+       if (flag & MCLIP_USE_PROXY) {
+               proxy = rendersize_to_proxy(user, flag);
+               render_flag = user->render_flag;
        }
 
        /* no cache or no cached postprocessed image */
@@ -582,19 +594,19 @@ static ImBuf *get_postprocessed_cached_frame(MovieClip *clip, MovieClipUser *use
 
 static ImBuf *put_postprocessed_frame_to_cache(MovieClip *clip, MovieClipUser *user, ImBuf *ibuf, int flag, int postprocess_flag)
 {
-       MovieClipCache *cache= clip->cache;
-       MovieTrackingCamera *camera= &clip->tracking.camera;
+       MovieClipCache *cache = clip->cache;
+       MovieTrackingCamera *camera = &clip->tracking.camera;
        ImBuf *postproc_ibuf = NULL;
 
        if (cache->postprocessed.ibuf)
                IMB_freeImBuf(cache->postprocessed.ibuf);
 
-       cache->postprocessed.framenr= user->framenr;
+       cache->postprocessed.framenr = user->framenr;
        cache->postprocessed.flag = postprocess_flag;
 
-       if (flag&MCLIP_USE_PROXY) {
-               cache->postprocessed.proxy= rendersize_to_proxy(user, flag);
-               cache->postprocessed.render_flag= user->render_flag;
+       if (flag & MCLIP_USE_PROXY) {
+               cache->postprocessed.proxy = rendersize_to_proxy(user, flag);
+               cache->postprocessed.render_flag = user->render_flag;
        }
        else {
                cache->postprocessed.proxy = IMB_PROXY_NONE;
@@ -604,10 +616,12 @@ static ImBuf *put_postprocessed_frame_to_cache(MovieClip *clip, MovieClipUser *u
        if (need_undistortion_postprocess(user, flag)) {
                copy_v2_v2(cache->postprocessed.principal, camera->principal);
                copy_v3_v3(&cache->postprocessed.k1, &camera->k1);
-               cache->postprocessed.undistoriton_used = 1;
+               cache->postprocessed.undistoriton_used = TRUE;
                postproc_ibuf= get_undistorted_ibuf(clip, NULL, ibuf);
        }
-       else cache->postprocessed.undistoriton_used = 0;
+       else {
+               cache->postprocessed.undistoriton_used = FALSE;
+       }
 
        if (postprocess_flag) {
                int disable_red   = postprocess_flag & MOVIECLIP_DISABLE_RED,
@@ -624,12 +638,12 @@ static ImBuf *put_postprocessed_frame_to_cache(MovieClip *clip, MovieClipUser *u
 
        IMB_refImBuf(postproc_ibuf);
 
-       cache->postprocessed.ibuf= postproc_ibuf;
+       cache->postprocessed.ibuf = postproc_ibuf;
 
        if (cache->stabilized.ibuf) {
                /* force stable buffer be re-calculated */
                IMB_freeImBuf(cache->stabilized.ibuf);
-               cache->stabilized.ibuf= NULL;
+               cache->stabilized.ibuf = NULL;
        }
 
        return postproc_ibuf;
@@ -638,8 +652,8 @@ static ImBuf *put_postprocessed_frame_to_cache(MovieClip *clip, MovieClipUser *u
 static ImBuf *movieclip_get_postprocessed_ibuf(MovieClip *clip, MovieClipUser *user, int flag,
                                                int postprocess_flag, int cache_flag)
 {
-       ImBuf *ibuf= NULL;
-       int framenr= user->framenr, need_postprocess= 0;
+       ImBuf *ibuf = NULL;
+       int framenr = user->framenr, need_postprocess = FALSE;
 
        /* cache isn't threadsafe itself and also loading of movies
         * can't happen from concurent threads that's why we use lock here */
@@ -650,23 +664,24 @@ static ImBuf *movieclip_get_postprocessed_ibuf(MovieClip *clip, MovieClipUser *u
                ibuf= get_postprocessed_cached_frame(clip, user, flag, postprocess_flag);
 
                if (!ibuf)
-                       need_postprocess= 1;
+                       need_postprocess = TRUE;
        }
 
        if (!ibuf)
                ibuf= get_imbuf_cache(clip, user, flag);
 
        if (!ibuf) {
-               int use_sequence= 0;
+               int use_sequence = FALSE;
 
                /* undistorted proxies for movies should be read as image sequence */
-               use_sequence= (user->render_flag&MCLIP_PROXY_RENDER_UNDISTORT) &&
-                       (user->render_size!=MCLIP_PROXY_RENDER_SIZE_FULL);
+               use_sequence = (user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT) &&
+                              (user->render_size != MCLIP_PROXY_RENDER_SIZE_FULL);
 
-               if (clip->source==MCLIP_SRC_SEQUENCE || use_sequence)
-                       ibuf= movieclip_load_sequence_file(clip, user, framenr, flag);
+               if (clip->source == MCLIP_SRC_SEQUENCE || use_sequence) {
+                       ibuf = movieclip_load_sequence_file(clip, user, framenr, flag);
+               }
                else {
-                       ibuf= movieclip_load_movie_file(clip, user, framenr, flag);
+                       ibuf = movieclip_load_movie_file(clip, user, framenr, flag);
                }
 
                if (ibuf && (cache_flag & MOVIECLIP_CACHE_SKIP) == 0)
@@ -674,13 +689,13 @@ static ImBuf *movieclip_get_postprocessed_ibuf(MovieClip *clip, MovieClipUser *u
        }
 
        if (ibuf) {
-               clip->lastframe= framenr;
+               clip->lastframe = framenr;
                real_ibuf_size(clip, user, ibuf, &clip->lastsize[0], &clip->lastsize[1]);
 
                /* postprocess frame and put to cache */
                if (need_postprocess) {
-                       ImBuf *tmpibuf= ibuf;
-                       ibuf= put_postprocessed_frame_to_cache(clip, user, tmpibuf, flag, postprocess_flag);
+                       ImBuf *tmpibuf = ibuf;
+                       ibuf = put_postprocessed_frame_to_cache(clip, user, tmpibuf, flag, postprocess_flag);
                        IMB_freeImBuf(tmpibuf);
                }
        }
@@ -714,7 +729,7 @@ static ImBuf *get_stable_cached_frame(MovieClip *clip, MovieClipUser *user, int
        short proxy = IMB_PROXY_NONE;
        int render_flag = 0;
 
-       if (clip->flag&MCLIP_USE_PROXY) {
+       if (clip->flag & MCLIP_USE_PROXY) {
                proxy = rendersize_to_proxy(user, clip->flag);
                render_flag = user->render_flag;
        }
@@ -724,7 +739,7 @@ static ImBuf *get_stable_cached_frame(MovieClip *clip, MovieClipUser *user, int
                return NULL;
 
        /* cached ibuf used different proxy settings */
-       if (cache->stabilized.render_flag!=render_flag || cache->stabilized.proxy!=proxy)
+       if (cache->stabilized.render_flag != render_flag || cache->stabilized.proxy != proxy)
                return NULL;
 
        if (cache->stabilized.postprocess_flag != postprocess_flag)
@@ -777,9 +792,9 @@ static ImBuf *put_stabilized_frame_to_cache(MovieClip *clip, MovieClipUser *user
        cache->stabilized.aspect = tracking->camera.pixel_aspect;
        cache->stabilized.filter = tracking->stabilization.filter;
 
-       if (clip->flag&MCLIP_USE_PROXY) {
-               cache->stabilized.proxy= rendersize_to_proxy(user, clip->flag);
-               cache->stabilized.render_flag= user->render_flag;
+       if (clip->flag & MCLIP_USE_PROXY) {
+               cache->stabilized.proxy = rendersize_to_proxy(user, clip->flag);
+               cache->stabilized.render_flag = user->render_flag;
        }
        else {
                cache->stabilized.proxy = IMB_PROXY_NONE;
@@ -795,37 +810,47 @@ static ImBuf *put_stabilized_frame_to_cache(MovieClip *clip, MovieClipUser *user
 
 ImBuf *BKE_movieclip_get_stable_ibuf(MovieClip *clip, MovieClipUser *user, float loc[2], float *scale, float *angle, int postprocess_flag)
 {
-       ImBuf *ibuf, *stableibuf= NULL;
-       int framenr= user->framenr;
+       ImBuf *ibuf, *stableibuf = NULL;
+       int framenr = user->framenr;
 
-       ibuf= BKE_movieclip_get_postprocessed_ibuf(clip, user, postprocess_flag);
+       ibuf = BKE_movieclip_get_postprocessed_ibuf(clip, user, postprocess_flag);
 
        if (!ibuf)
                return NULL;
 
-       if (clip->tracking.stabilization.flag&TRACKING_2D_STABILIZATION) {
+       if (clip->tracking.stabilization.flag & TRACKING_2D_STABILIZATION) {
                MovieClipCache *cache= clip->cache;
 
-               stableibuf= get_stable_cached_frame(clip, user, framenr, postprocess_flag);
+               stableibuf = get_stable_cached_frame(clip, user, framenr, postprocess_flag);
 
                if (!stableibuf)
-                       stableibuf= put_stabilized_frame_to_cache(clip, user, ibuf, framenr, postprocess_flag);
+                       stableibuf = put_stabilized_frame_to_cache(clip, user, ibuf, framenr, postprocess_flag);
+
+               if (loc)
+                       copy_v2_v2(loc, cache->stabilized.loc);
 
-               if (loc)                copy_v2_v2(loc, cache->stabilized.loc);
-               if (scale)      *scale= cache->stabilized.scale;
-               if (angle)      *angle= cache->stabilized.angle;
+               if (scale)
+                       *scale= cache->stabilized.scale;
+
+               if (angle)
+                       *angle= cache->stabilized.angle;
        }
        else {
-               if (loc)                zero_v2(loc);
-               if (scale)      *scale= 1.0f;
-               if (angle)      *angle= 0.0f;
+               if (loc)
+                       zero_v2(loc);
+
+               if (scale)
+                       *scale= 1.0f;
+
+               if (angle)
+                       *angle= 0.0f;
 
-               stableibuf= ibuf;
+               stableibuf = ibuf;
        }
 
-       if (stableibuf!=ibuf) {
+       if (stableibuf != ibuf) {
                IMB_freeImBuf(ibuf);
-               ibuf= stableibuf;
+               ibuf = stableibuf;
        }
 
        return ibuf;
@@ -834,31 +859,31 @@ ImBuf *BKE_movieclip_get_stable_ibuf(MovieClip *clip, MovieClipUser *user, float
 
 int BKE_movieclip_has_frame(MovieClip *clip, MovieClipUser *user)
 {
-       ImBuf *ibuf= BKE_movieclip_get_ibuf(clip, user);
+       ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
 
        if (ibuf) {
                IMB_freeImBuf(ibuf);
-               return 1;
+               return TRUE;
        }
 
-       return 0;
+       return FALSE;
 }
 
 void BKE_movieclip_get_size(MovieClip *clip, MovieClipUser *user, int *width, int *height)
 {
-       if (user->framenr==clip->lastframe) {
-               *width= clip->lastsize[0];
-               *height= clip->lastsize[1];
+       if (user->framenr == clip->lastframe) {
+               *width = clip->lastsize[0];
+               *height = clip->lastsize[1];
        }
        else {
-               ImBuf *ibuf= BKE_movieclip_get_ibuf(clip, user);
+               ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
 
                if (ibuf && ibuf->x && ibuf->y) {
                        real_ibuf_size(clip, user, ibuf, width, height);
                }
                else {
-                       *width= 0;
-                       *height= 0;
+                       *width = 0;
+                       *height = 0;
                }
 
                if (ibuf)
@@ -873,20 +898,20 @@ int BKE_movieclip_get_duration(struct MovieClip *clip)
 
 void BKE_movieclip_aspect(MovieClip *clip, float *aspx, float *aspy)
 {
-       *aspx= *aspy= 1.0;
+       *aspx = *aspy = 1.0;
 
        /* x is always 1 */
-       *aspy = clip->aspy/clip->aspx/clip->tracking.camera.pixel_aspect;
+       *aspy = clip->aspy / clip->aspx / clip->tracking.camera.pixel_aspect;
 }
 
 /* get segments of cached frames. useful for debugging cache policies */
 void BKE_movieclip_get_cache_segments(MovieClip *clip, MovieClipUser *user, int *totseg_r, int **points_r)
 {
-       *totseg_r= 0;
-       *points_r= NULL;
+       *totseg_r = 0;
+       *points_r = NULL;
 
        if (clip->cache) {
-               int proxy= rendersize_to_proxy(user, clip->flag);
+               int proxy = rendersize_to_proxy(user, clip->flag);
 
                IMB_moviecache_get_cache_segments(clip->cache->moviecache, proxy, user->render_flag, totseg_r, points_r);
        }
@@ -896,7 +921,7 @@ void BKE_movieclip_user_set_frame(MovieClipUser *iuser, int framenr)
 {
        /* TODO: clamp framenr here? */
 
-       iuser->framenr= framenr;
+       iuser->framenr = framenr;
 }
 
 static void free_buffers(MovieClip *clip)
@@ -911,12 +936,12 @@ static void free_buffers(MovieClip *clip)
                        IMB_freeImBuf(clip->cache->stabilized.ibuf);
 
                MEM_freeN(clip->cache);
-               clip->cache= NULL;
+               clip->cache = NULL;
        }
 
        if (clip->anim) {
                IMB_free_anim(clip->anim);
-               clip->anim= FALSE;
+               clip->anim = NULL;
        }
 
        BKE_free_animdata((ID *) clip);
@@ -927,11 +952,13 @@ void BKE_movieclip_reload(MovieClip *clip)
        /* clear cache */
        free_buffers(clip);
 
-       clip->tracking.stabilization.ok= 0;
+       clip->tracking.stabilization.ok = FALSE;
 
        /* update clip source */
-       if (BLI_testextensie_array(clip->name, imb_ext_movie)) clip->source= MCLIP_SRC_MOVIE;
-       else clip->source= MCLIP_SRC_SEQUENCE;
+       if (BLI_testextensie_array(clip->name, imb_ext_movie))
+               clip->source = MCLIP_SRC_MOVIE;
+       else
+               clip->source = MCLIP_SRC_SEQUENCE;
 }
 
 void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClipScopes *scopes)
@@ -941,44 +968,44 @@ void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClip
 
        if (scopes->track_preview) {
                IMB_freeImBuf(scopes->track_preview);
-               scopes->track_preview= NULL;
+               scopes->track_preview = NULL;
        }
 
-       scopes->marker= NULL;
-       scopes->track= NULL;
+       scopes->marker = NULL;
+       scopes->track = NULL;
 
        if (clip) {
-               MovieTrackingTrack *act_track= BKE_tracking_active_track(&clip->tracking);
+               MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
 
                if (act_track) {
-                       MovieTrackingTrack *track= act_track;
-                       MovieTrackingMarker *marker= BKE_tracking_get_marker(track, user->framenr);
+                       MovieTrackingTrack *track = act_track;
+                       MovieTrackingMarker *marker = BKE_tracking_get_marker(track, user->framenr);
 
-                       if (marker->flag&MARKER_DISABLED) {
-                               scopes->track_disabled= 1;
+                       if (marker->flag & MARKER_DISABLED) {
+                               scopes->track_disabled = TRUE;
                        }
                        else {
-                               ImBuf *ibuf= BKE_movieclip_get_ibuf(clip, user);
+                               ImBuf *ibuf = BKE_movieclip_get_ibuf(clip, user);
 
-                               scopes->track_disabled= 0;
+                               scopes->track_disabled = FALSE;
 
                                if (ibuf && ibuf->rect) {
                                        ImBuf *tmpibuf;
-                                       MovieTrackingMarker undist_marker= *marker;
+                                       MovieTrackingMarker undist_marker = *marker;
 
-                                       if (user->render_flag&MCLIP_PROXY_RENDER_UNDISTORT) {
+                                       if (user->render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
                                                int width, height;
-                                               float aspy= 1.0f/clip->tracking.camera.pixel_aspect;
+                                               float aspy= 1.0f / clip->tracking.camera.pixel_aspect;
 
                                                BKE_movieclip_get_size(clip, user, &width, &height);
 
-                                               undist_marker.pos[0]*= width;
-                                               undist_marker.pos[1]*= height*aspy;
+                                               undist_marker.pos[0] *= width;
+                                               undist_marker.pos[1] *= height*aspy;
 
                                                BKE_tracking_invert_intrinsics(&clip->tracking, undist_marker.pos, undist_marker.pos);
 
-                                               undist_marker.pos[0]/= width;
-                                               undist_marker.pos[1]/= height*aspy;
+                                               undist_marker.pos[0] /= width;
+                                               undist_marker.pos[1] /= height*aspy;
                                        }
 
                                        /* NOTE: margin should be kept in sync with value from ui_draw_but_TRACKPREVIEW */
@@ -997,46 +1024,46 @@ void BKE_movieclip_update_scopes(MovieClip *clip, MovieClipUser *user, MovieClip
                                IMB_freeImBuf(ibuf);
                        }
 
-                       if ((track->flag&TRACK_LOCKED)==0) {
-                               scopes->marker= marker;
-                               scopes->track= track;
-                               scopes->slide_scale[0]= track->pat_max[0]-track->pat_min[0];
-                               scopes->slide_scale[1]= track->pat_max[1]-track->pat_min[1];
+                       if ((track->flag & TRACK_LOCKED)==0) {
+                               scopes->marker = marker;
+                               scopes->track = track;
+                               scopes->slide_scale[0] = track->pat_max[0]-track->pat_min[0];
+                               scopes->slide_scale[1] = track->pat_max[1]-track->pat_min[1];
                        }
                }
        }
 
-       scopes->framenr= user->framenr;
-       scopes->ok= 1;
+       scopes->framenr = user->framenr;
+       scopes->ok = TRUE;
 }
 
 static void movieclip_build_proxy_ibuf(MovieClip *clip, ImBuf *ibuf, int cfra, int proxy_render_size, int undistorted)
 {
        char name[FILE_MAX];
        int quality, rectx, recty;
-       int size= rendersize_to_number(proxy_render_size);
+       int size = rendersize_to_number(proxy_render_size);
        ImBuf *scaleibuf;
 
        get_proxy_fname(clip, proxy_render_size, undistorted, cfra, name);
 
-       rectx= ibuf->x*size/100.0f;
-       recty= ibuf->y*size/100.0f;
+       rectx = ibuf->x * size / 100.0f;
+       recty = ibuf->y * size / 100.0f;
 
-       scaleibuf= IMB_dupImBuf(ibuf);
+       scaleibuf = IMB_dupImBuf(ibuf);
 
        IMB_scaleImBuf(scaleibuf, (short)rectx, (short)recty);
 
-       quality= clip->proxy.quality;
-       scaleibuf->ftype= JPG | quality;
+       quality = clip->proxy.quality;
+       scaleibuf->ftype = JPG | quality;
 
        /* unsupported feature only confuses other s/w */
-       if (scaleibuf->planes==32)
-               scaleibuf->planes= 24;
+       if (scaleibuf->planes == 32)
+               scaleibuf->planes = 24;
 
        BLI_lock_thread(LOCK_MOVIECLIP);
 
        BLI_make_existing_file(name);
-       if (IMB_saveiff(scaleibuf, name, IB_rect)==0)
+       if (IMB_saveiff(scaleibuf, name, IB_rect) == 0)
                perror(name);
 
        BLI_unlock_thread(LOCK_MOVIECLIP);
@@ -1045,30 +1072,30 @@ static void movieclip_build_proxy_ibuf(MovieClip *clip, ImBuf *ibuf, int cfra, i
 }
 
 void BKE_movieclip_build_proxy_frame(MovieClip *clip, int clip_flag, struct MovieDistortion *distortion,
-                       int cfra, int *build_sizes, int build_count, int undistorted)
+                                     int cfra, int *build_sizes, int build_count, int undistorted)
 {
        ImBuf *ibuf;
        MovieClipUser user;
 
-       user.framenr= cfra;
-       user.render_flag= 0;
-       user.render_size= MCLIP_PROXY_RENDER_SIZE_FULL;
+       user.framenr = cfra;
+       user.render_flag = 0;
+       user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
 
-       ibuf= BKE_movieclip_get_ibuf_flag(clip, &user, clip_flag, MOVIECLIP_CACHE_SKIP);
+       ibuf = BKE_movieclip_get_ibuf_flag(clip, &user, clip_flag, MOVIECLIP_CACHE_SKIP);
 
        if (ibuf) {
-               ImBuf *tmpibuf= ibuf;
+               ImBuf *tmpibuf = ibuf;
                int i;
 
                if (undistorted)
-                       tmpibuf= get_undistorted_ibuf(clip, distortion, ibuf);
+                       tmpibuf = get_undistorted_ibuf(clip, distortion, ibuf);
 
-               for (i= 0; i<build_count; i++)
+               for (i = 0; i < build_count; i++)
                        movieclip_build_proxy_ibuf(clip, tmpibuf, cfra, build_sizes[i], undistorted);
 
                IMB_freeImBuf(ibuf);
 
-               if (tmpibuf!=ibuf)
+               if (tmpibuf != ibuf)
                        IMB_freeImBuf(tmpibuf);
        }
 }
@@ -1088,53 +1115,53 @@ void unlink_movieclip(Main *bmain, MovieClip *clip)
        Scene *sce;
        Object *ob;
 
-       for (scr= bmain->screen.first; scr; scr= scr->id.next) {
-               for (area= scr->areabase.first; area; area= area->next) {
-                       for (sl= area->spacedata.first; sl; sl= sl->next) {
-                               if (sl->spacetype==SPACE_CLIP) {
-                                       SpaceClip *sc= (SpaceClip *) sl;
+       for (scr = bmain->screen.first; scr; scr = scr->id.next) {
+               for (area = scr->areabase.first; area; area = area->next) {
+                       for (sl = area->spacedata.first; sl; sl = sl->next) {
+                               if (sl->spacetype == SPACE_CLIP) {
+                                       SpaceClip *sc = (SpaceClip *) sl;
 
-                                       if (sc->clip==clip)
-                                               sc->clip= NULL;
+                                       if (sc->clip == clip)
+                                               sc->clip = NULL;
                                }
-                               else if (sl->spacetype==SPACE_VIEW3D) {
-                                       View3D *v3d= (View3D *) sl;
+                               else if (sl->spacetype == SPACE_VIEW3D) {
+                                       View3D *v3d = (View3D *) sl;
                                        BGpic *bgpic;
 
-                                       for (bgpic= v3d->bgpicbase.first; bgpic; bgpic= bgpic->next) {
-                                               if (bgpic->clip==clip)
-                                                       bgpic->clip= NULL;
+                                       for (bgpic = v3d->bgpicbase.first; bgpic; bgpic = bgpic->next) {
+                                               if (bgpic->clip == clip)
+                                                       bgpic->clip = NULL;
                                        }
                                }
                        }
                }
        }
 
-       for (sce= bmain->scene.first; sce; sce= sce->id.next) {
-               if (sce->clip==clip)
-                       sce->clip= NULL;
+       for (sce = bmain->scene.first; sce; sce = sce->id.next) {
+               if (sce->clip == clip)
+                       sce->clip = NULL;
        }
 
-       for (ob= bmain->object.first; ob; ob= ob->id.next) {
+       for (ob = bmain->object.first; ob; ob = ob->id.next) {
                bConstraint *con;
 
-               for (con= ob->constraints.first; con; con= con->next) {
-                       bConstraintTypeInfo *cti= constraint_get_typeinfo(con);
+               for (con = ob->constraints.first; con; con = con->next) {
+                       bConstraintTypeInfo *cti = constraint_get_typeinfo(con);
 
-                       if (cti->type==CONSTRAINT_TYPE_FOLLOWTRACK) {
-                               bFollowTrackConstraint *data= (bFollowTrackConstraint *) con->data;
+                       if (cti->type == CONSTRAINT_TYPE_FOLLOWTRACK) {
+                               bFollowTrackConstraint *data = (bFollowTrackConstraint *) con->data;
 
-                               if (data->clip==clip)
-                                       data->clip= NULL;
+                               if (data->clip == clip)
+                                       data->clip = NULL;
                        }
-                       else if (cti->type==CONSTRAINT_TYPE_CAMERASOLVER) {
-                               bCameraSolverConstraint *data= (bCameraSolverConstraint *) con->data;
+                       else if (cti->type == CONSTRAINT_TYPE_CAMERASOLVER) {
+                               bCameraSolverConstraint *data = (bCameraSolverConstraint *) con->data;
 
-                               if (data->clip==clip)
-                                       data->clip= NULL;
+                               if (data->clip == clip)
+                                       data->clip = NULL;
                        }
                }
        }
 
-       clip->id.us= 0;
+       clip->id.us = 0;
 }
index bdecc6884ea6508106b5f28d1ded537e84232298..b35b654a55b28514ffb6c321d770f51d01ad2842 100644 (file)
@@ -55,7 +55,6 @@
 #include "BKE_movieclip.h"
 #include "BKE_object.h"
 #include "BKE_scene.h"
-#include "BKE_main.h"  // XXX: ...
 
 #include "IMB_imbuf_types.h"
 #include "IMB_imbuf.h"
@@ -78,24 +77,24 @@ static struct {
 
 void BKE_tracking_init_settings(MovieTracking *tracking)
 {
-       tracking->camera.sensor_width= 35.0f;
-       tracking->camera.pixel_aspect= 1.0f;
-       tracking->camera.units= CAMERA_UNITS_MM;
-
-       tracking->settings.default_tracker= TRACKER_HYBRID;
-       tracking->settings.default_minimum_correlation= 0.75;
-       tracking->settings.default_pattern_size= 11;
-       tracking->settings.default_search_size= 51;
-       tracking->settings.default_pyramid_levels= 2;
-       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;
+       tracking->camera.sensor_width = 35.0f;
+       tracking->camera.pixel_aspect = 1.0f;
+       tracking->camera.units = CAMERA_UNITS_MM;
+
+       tracking->settings.default_tracker = TRACKER_HYBRID;
+       tracking->settings.default_minimum_correlation = 0.75;
+       tracking->settings.default_pattern_size = 11;
+       tracking->settings.default_search_size = 51;
+       tracking->settings.default_pyramid_levels = 2;
+       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_new_object(tracking, "Camera");
 }
@@ -112,143 +111,152 @@ void BKE_tracking_clamp_track(MovieTrackingTrack *track, int event)
        }
 
        /* sort */
-       for (a= 0; a<2; a++) {
-               if (track->pat_min[a]>track->pat_max[a])
+       for (a = 0; a < 2; a++) {
+               if (track->pat_min[a] > track->pat_max[a])
                        SWAP(float, track->pat_min[a], track->pat_max[a]);
 
-               if (track->search_min[a]>track->search_max[a])
+               if (track->search_min[a] > track->search_max[a])
                        SWAP(float, track->search_min[a], track->search_max[a]);
        }
 
        /* compute the effective pattern size, which differs from the fine resolution
         * pattern size for the pyramid KLT tracker */
-       for (a= 0; a<2; a++) {
+       for (a = 0; a < 2; a++) {
                pat_min[a] = max_pyramid_level_factor * track->pat_min[a];
                pat_max[a] = max_pyramid_level_factor * track->pat_max[a];
        }
 
-       if (event==CLAMP_PAT_DIM) {
-               for (a= 0; a<2; a++) {
+       if (event == CLAMP_PAT_DIM) {
+               for (a = 0; a < 2; a++) {
                        /* search shouldn't be resized smaller than pattern */
-                       track->search_min[a]= MIN2(pat_min[a], track->search_min[a]);
-                       track->search_max[a]= MAX2(pat_max[a], track->search_max[a]);
+                       track->search_min[a] = MIN2(pat_min[a], track->search_min[a]);
+                       track->search_max[a] = MAX2(pat_max[a], track->search_max[a]);
                }
        }
-       else if (event==CLAMP_PAT_POS) {
+       else if (event == CLAMP_PAT_POS) {
                float dim[2];
+
                sub_v2_v2v2(dim, track->pat_max, track->pat_min);
 
-               for (a= 0; a<2; a++) {
+               for (a = 0; a < 2; a++) {
                        /* pattern shouldn't be moved outside of search */
                        if (pat_min[a] < track->search_min[a]) {
-                               track->pat_min[a]= track->search_min[a] - (pat_min[a] - track->pat_min[a]);
-                               track->pat_max[a]= track->pat_min[a] + dim[a];
+                               track->pat_min[a] = track->search_min[a] - (pat_min[a] - track->pat_min[a]);
+                               track->pat_max[a] = track->pat_min[a] + dim[a];
                        }
                        if (track->pat_max[a] > track->search_max[a]) {
-                               track->pat_max[a]= track->search_max[a] - (pat_max[a] - track->pat_max[a]);
-                               track->pat_min[a]= track->pat_max[a] - dim[a];
+                               track->pat_max[a] = track->search_max[a] - (pat_max[a] - track->pat_max[a]);
+                               track->pat_min[a] = track->pat_max[a] - dim[a];
                        }
                }
        }
-       else if (event==CLAMP_SEARCH_DIM) {
-               for (a= 0; a<2; a++) {
+       else if (event == CLAMP_SEARCH_DIM) {
+               for (a = 0; a < 2; a++) {
                        /* search shouldn't be resized smaller than pattern */
-                       track->search_min[a]= MIN2(pat_min[a], track->search_min[a]);
-                       track->search_max[a]= MAX2(pat_max[a], track->search_max[a]);
+                       track->search_min[a] = MIN2(pat_min[a], track->search_min[a]);
+                       track->search_max[a] = MAX2(pat_max[a], track->search_max[a]);
                }
        }
-       else if (event==CLAMP_SEARCH_POS) {
+       else if (event == CLAMP_SEARCH_POS) {
                float dim[2];
+
                sub_v2_v2v2(dim, track->search_max, track->search_min);
 
-               for (a= 0; a<2; a++) {
+               for (a = 0; a < 2; a++) {
                        /* search shouldn't be moved inside pattern */
                        if (track->search_min[a] > pat_min[a]) {
-                               track->search_min[a]= pat_min[a];
-                               track->search_max[a]= track->search_min[a]+dim[a];
+                               track->search_min[a] = pat_min[a];
+                               track->search_max[a] = track->search_min[a]+dim[a];
                        }
                        if (track->search_max[a] < pat_max[a]) {
-                               track->search_max[a]= pat_max[a];
-                               track->search_min[a]= track->search_max[a]-dim[a];
+                               track->search_max[a] = pat_max[a];
+                               track->search_min[a] = track->search_max[a]-dim[a];
                        }
                }
        }
-       else if (event==CLAMP_PYRAMID_LEVELS || (event==CLAMP_SEARCH_DIM && track->tracker == TRACKER_KLT)) {
+       else if (event == CLAMP_PYRAMID_LEVELS || (event == CLAMP_SEARCH_DIM && track->tracker == TRACKER_KLT)) {
                float dim[2];
                sub_v2_v2v2(dim, track->pat_max, track->pat_min);
                {
-                       float search_ratio= 2.3f * max_pyramid_level_factor;
+                       float search_ratio = 2.3f * max_pyramid_level_factor;
 
                        /* resize the search area to something sensible based
                         * on the number of pyramid levels */
-                       for (a= 0; a<2; a++) {
-                               track->search_min[a]= search_ratio * track->pat_min[a];
-                               track->search_max[a]= search_ratio * track->pat_max[a];
+                       for (a = 0; a < 2; a++) {
+                               track->search_min[a] = search_ratio * track->pat_min[a];
+                               track->search_max[a] = search_ratio * track->pat_max[a];
                        }
                }
        }
 
        /* marker's center should be in center of pattern */
-       if (event==CLAMP_PAT_DIM || event==CLAMP_PAT_POS) {
+       if (event == CLAMP_PAT_DIM || event == CLAMP_PAT_POS) {
                float dim[2];
+
                sub_v2_v2v2(dim, track->pat_max, track->pat_min);
 
-               for (a= 0; a<2; a++) {
-                       track->pat_min[a]= -dim[a]/2.0f;
-                       track->pat_max[a]= dim[a]/2.0f;
+               for (a = 0; a < 2; a++) {
+                       track->pat_min[a] = -dim[a]/2.0f;
+                       track->pat_max[a] = dim[a]/2.0f;
                }
        }
 }
 
 void BKE_tracking_track_flag(MovieTrackingTrack *track, int area, int flag, int clear)
 {
-       if (area==TRACK_AREA_NONE)
+       if (area == TRACK_AREA_NONE)
                return;
 
        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;
+               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;
+               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;
        }
 }
 
 MovieTrackingTrack *BKE_tracking_add_track(MovieTracking *tracking, ListBase *tracksbase, float x, float y,
-                       int framenr, int width, int height)
+                                           int framenr, int width, int height)
 {
        MovieTrackingTrack *track;
        MovieTrackingMarker marker;
-       MovieTrackingSettings *settings= &tracking->settings;
+       MovieTrackingSettings *settings = &tracking->settings;
 
-       float half_pattern= (float)settings->default_pattern_size/2.0f;
-       float half_search= (float)settings->default_search_size/2.0f;
+       float half_pattern = (float)settings->default_pattern_size / 2.0f;
+       float half_search = (float)settings->default_search_size / 2.0f;
        float pat[2], search[2];
 
-       pat[0]= half_pattern/(float)width;
-       pat[1]= half_pattern/(float)height;
+       pat[0] = half_pattern / (float)width;
+       pat[1] = half_pattern / (float)height;
 
-       search[0]= half_search/(float)width;
-       search[1]= half_search/(float)height;
+       search[0] = half_search / (float)width;
+       search[1] = half_search / (float)height;
 
-       track= MEM_callocN(sizeof(MovieTrackingTrack), "add_marker_exec track");
+       track = MEM_callocN(sizeof(MovieTrackingTrack), "add_marker_exec track");
        strcpy(track->name, "Track");
 
-       track->tracker= settings->default_tracker;
-       track->pyramid_levels= settings->default_pyramid_levels;
-       track->minimum_correlation= settings->default_minimum_correlation;
-       track->margin= settings->default_margin;
-       track->pattern_match= settings->default_pattern_match;
-       track->frames_limit= settings->default_frames_limit;
-       track->flag= settings->default_flag;
+       track->tracker = settings->default_tracker;
+       track->pyramid_levels = settings->default_pyramid_levels;
+       track->minimum_correlation = settings->default_minimum_correlation;
+       track->margin = settings->default_margin;
+       track->pattern_match = settings->default_pattern_match;
+       track->frames_limit = settings->default_frames_limit;
+       track->flag = settings->default_flag;
 
        memset(&marker, 0, sizeof(marker));
-       marker.pos[0]= x;
-       marker.pos[1]= y;
-       marker.framenr= framenr;
+       marker.pos[0] = x;
+       marker.pos[1] = y;
+       marker.framenr = framenr;
 
        copy_v2_v2(track->pat_max, pat);
        negate_v2_v2(track->pat_min, pat);
@@ -272,32 +280,34 @@ MovieTrackingMarker *BKE_tracking_insert_marker(MovieTrackingTrack *track, Movie
        MovieTrackingMarker *old_marker= NULL;
 
        if (track->markersnr)
-               old_marker= BKE_tracking_exact_marker(track, marker->framenr);
+               old_marker = BKE_tracking_exact_marker(track, marker->framenr);
 
        if (old_marker) {
-               *old_marker= *marker;
+               *old_marker = *marker;
 
                return old_marker;
        }
        else {
-               int a= track->markersnr;
+               int a = track->markersnr;
 
                while (a--) {
-                       if (track->markers[a].framenr<marker->framenr)
+                       if (track->markers[a].framenr < marker->framenr)
                                break;
                }
 
                track->markersnr++;
 
-               if (track->markers) track->markers= MEM_reallocN(track->markers, sizeof(MovieTrackingMarker)*track->markersnr);
-               else track->markers= MEM_callocN(sizeof(MovieTrackingMarker), "MovieTracking markers");
+               if (track->markers)
+                       track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker)*track->markersnr);
+               else
+                       track->markers = MEM_callocN(sizeof(MovieTrackingMarker), "MovieTracking markers");
 
                memmove(track->markers+a+2, track->markers+a+1, (track->markersnr-a-2)*sizeof(MovieTrackingMarker));
-               track->markers[a+1]= *marker;
+               track->markers[a+1] = *marker;
 
-               track->last_marker= a+1;
+               track->last_marker = a + 1;
 
-               return &track->markers[a+1];
+               return &track->markers[a + 1];
        }
 }
 
@@ -306,16 +316,16 @@ void BKE_tracking_delete_marker(MovieTrackingTrack *track, int framenr)
        int a= 0;
 
        while (a<track->markersnr) {
-               if (track->markers[a].framenr==framenr) {
-                       if (track->markersnr>1) {
+               if (track->markers[a].framenr == framenr) {
+                       if (track->markersnr > 1) {
                                memmove(track->markers+a, track->markers+a+1, (track->markersnr-a-1)*sizeof(MovieTrackingMarker));
                                track->markersnr--;
-                               track->markers= MEM_reallocN(track->markers, sizeof(MovieTrackingMarker)*track->markersnr);
+                               track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker)*track->markersnr);
                        }
                        else {
                                MEM_freeN(track->markers);
-                               track->markers= NULL;
-                               track->markersnr= 0;
+                               track->markers = NULL;
+                               track->markersnr = 0;
                        }
 
                        break;
@@ -327,22 +337,23 @@ void BKE_tracking_delete_marker(MovieTrackingTrack *track, int framenr)
 
 MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int framenr)
 {
-       int a= track->markersnr-1;
+       int a = track->markersnr-1;
 
        if (!track->markersnr)
                return NULL;
 
        /* approximate pre-first framenr marker with first marker */
-       if (framenr<track->markers[0].framenr)
+       if (framenr < track->markers[0].framenr)
                return &track->markers[0];
 
-       if (track->last_marker<track->markersnr)
-               a= track->last_marker;
+       if (track->last_marker < track->markersnr)
+               a = track->last_marker;
+
+       if (track->markers[a].framenr <= framenr) {
+               while (a < track->markersnr && track->markers[a].framenr <= framenr) {
+                       if (track->markers[a].framenr == framenr) {
+                               track->last_marker = a;
 
-       if (track->markers[a].framenr<=framenr) {
-               while (a<track->markersnr && track->markers[a].framenr<=framenr) {
-                       if (track->markers[a].framenr==framenr) {
-                               track->last_marker= a;
                                return &track->markers[a];
                        }
                        a++;
@@ -352,9 +363,10 @@ MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int fram
                return &track->markers[a-1];
        }
        else {
-               while (a>=0 && track->markers[a].framenr>=framenr) {
-                       if (track->markers[a].framenr==framenr) {
-                               track->last_marker= a;
+               while (a >= 0 && track->markers[a].framenr >= framenr) {
+                       if (track->markers[a].framenr == framenr) {
+                               track->last_marker = a;
+
                                return &track->markers[a];
                        }
 
@@ -370,16 +382,16 @@ MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int fram
 
 MovieTrackingMarker *BKE_tracking_ensure_marker(MovieTrackingTrack *track, int framenr)
 {
-       MovieTrackingMarker *marker= BKE_tracking_get_marker(track, framenr);
+       MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
 
-       if (marker->framenr!=framenr) {
+       if (marker->framenr != framenr) {
                MovieTrackingMarker marker_new;
 
-               marker_new= *marker;
-               marker_new.framenr= framenr;
+               marker_new = *marker;
+               marker_new.framenr = framenr;
 
                BKE_tracking_insert_marker(track, &marker_new);
-               marker= BKE_tracking_get_marker(track, framenr);
+               marker = BKE_tracking_get_marker(track, framenr);
        }
 
        return marker;
@@ -387,9 +399,9 @@ MovieTrackingMarker *BKE_tracking_ensure_marker(MovieTrackingTrack *track, int f
 
 MovieTrackingMarker *BKE_tracking_exact_marker(MovieTrackingTrack *track, int framenr)
 {
-       MovieTrackingMarker *marker= BKE_tracking_get_marker(track, framenr);
+       MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
 
-       if (marker->framenr!=framenr)
+       if (marker->framenr != framenr)
                return NULL;
 
        return marker;
@@ -409,19 +421,22 @@ int BKE_tracking_has_enabled_marker(MovieTrackingTrack *track, int framenr)
 
 void BKE_tracking_free_track(MovieTrackingTrack *track)
 {
-       if (track->markers) MEM_freeN(track->markers);
+       if (track->markers)
+               MEM_freeN(track->markers);
 }
 
 static void put_disabled_marker(MovieTrackingTrack *track, MovieTrackingMarker *ref_marker, int before, int overwrite)
 {
        MovieTrackingMarker marker_new;
 
-       marker_new= *ref_marker;
-       marker_new.flag&= ~MARKER_TRACKED;
-       marker_new.flag|= MARKER_DISABLED;
+       marker_new = *ref_marker;
+       marker_new.flag &= ~MARKER_TRACKED;
+       marker_new.flag |= MARKER_DISABLED;
 
-       if (before) marker_new.framenr--;
-       else marker_new.framenr++;
+       if (before)
+               marker_new.framenr--;
+       else
+               marker_new.framenr++;
 
        if (!BKE_tracking_has_marker(track, marker_new.framenr) || overwrite)
                BKE_tracking_insert_marker(track, &marker_new);
@@ -431,12 +446,13 @@ void BKE_tracking_clear_path(MovieTrackingTrack *track, int ref_frame, int actio
 {
        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);
+       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;
                        }
@@ -447,14 +463,15 @@ void BKE_tracking_clear_path(MovieTrackingTrack *track, int ref_frame, int actio
                if (track->markersnr)
                        put_disabled_marker(track, &track->markers[track->markersnr-1], 0, 1);
        }
-       else if (action==TRACK_CLEAR_UPTO) {
+       else if (action == TRACK_CLEAR_UPTO) {
                a= track->markersnr-1;
-               while (a>=0) {
-                       if (track->markers[a].framenr<=ref_frame) {
+
+               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);
+                               track->markersnr = track->markersnr-a;
+                               track->markers = MEM_reallocN(track->markers, sizeof(MovieTrackingMarker)*track->markersnr);
 
                                break;
                        }
@@ -465,15 +482,15 @@ void BKE_tracking_clear_path(MovieTrackingTrack *track, int ref_frame, int actio
                if (track->markersnr)
                        put_disabled_marker(track, &track->markers[0], 1, 1);
        }
-       else if (action==TRACK_CLEAR_ALL) {
+       else if (action == TRACK_CLEAR_ALL) {
                MovieTrackingMarker *marker, marker_new;
 
-               marker= BKE_tracking_get_marker(track, ref_frame);
-               marker_new= *marker;
+               marker = BKE_tracking_get_marker(track, ref_frame);
+               marker_new = *marker;
 
                MEM_freeN(track->markers);
-               track->markers= NULL;
-               track->markersnr= 0;
+               track->markers = NULL;
+               track->markersnr = 0;
 
                BKE_tracking_insert_marker(track, &marker_new);
 
@@ -484,27 +501,28 @@ void BKE_tracking_clear_path(MovieTrackingTrack *track, int ref_frame, int actio
 
 void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack *src_track)
 {
-       int i= 0, a= 0, b= 0;
+       int i = 0, a = 0, b = 0, tot;
        MovieTrackingMarker *markers;
 
-       markers= MEM_callocN((dst_track->markersnr+src_track->markersnr)*sizeof(MovieTrackingMarker), "tmp tracking joined tracks");
+       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++];
+               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 (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] = 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].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) {
+                       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 */
@@ -517,6 +535,7 @@ void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack
                                                  (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];
@@ -536,6 +555,7 @@ void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack
                                        a = start_a;
                                        b = start_b;
 
+                                       /* linear interpolation for intersecting frames */
                                        for (j = 0; j < len; j++) {
                                                float fac = 0.5f;
 
@@ -548,7 +568,7 @@ void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack
                                                marker_a = &src_track->markers[a];
                                                marker_b = &dst_track->markers[b];
 
-                                               markers[i]= 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++;
@@ -558,9 +578,9 @@ void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack
                                        /* 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] = src_track->markers[a];
                        }
-                       else markers[i]= dst_track->markers[b];
+                       else markers[i] = dst_track->markers[b];
 
                        a++;
                        b++;
@@ -571,10 +591,10 @@ void BKE_tracking_join_tracks(MovieTrackingTrack *dst_track, MovieTrackingTrack
 
        MEM_freeN(dst_track->markers);
 
-       dst_track->markers= MEM_callocN(i*sizeof(MovieTrackingMarker), "tracking joined tracks");
+       dst_track->markers = MEM_callocN(i*sizeof(MovieTrackingMarker), "tracking joined tracks");
        memcpy(dst_track->markers, markers, i*sizeof(MovieTrackingMarker));
 
-       dst_track->markersnr= i;
+       dst_track->markersnr = i;
 
        MEM_freeN(markers);
 }
@@ -583,7 +603,7 @@ static void tracking_tracks_free(ListBase *tracks)
 {
        MovieTrackingTrack *track;
 
-       for (track= tracks->first; track; track= track->next) {
+       for (track = tracks->first; track; track = track->next) {
                BKE_tracking_free_track(track);
        }
 
@@ -606,7 +626,7 @@ static void tracking_objects_free(ListBase *objects)
 {
        MovieTrackingObject *object;
 
-       for (object= objects->first; object; object= object->next)
+       for (object = objects->first; object; object = object->next)
                tracking_object_free(object);
 
        BLI_freelistN(objects);
@@ -631,7 +651,7 @@ static MovieTrackingTrack *duplicate_track(MovieTrackingTrack *track)
 
        new_track = MEM_callocN(sizeof(MovieTrackingTrack), "tracksMapMerge new_track");
 
-       *new_track= *track;
+       *new_track = *track;
        new_track->next = new_track->prev = NULL;
 
        new_track->markers = MEM_dupallocN(new_track->markers);
@@ -710,20 +730,20 @@ typedef struct TracksMap {
 
 static TracksMap *tracks_map_new(const char *object_name, int is_camera, int num_tracks, int customdata_size)
 {
-       TracksMap *map= MEM_callocN(sizeof(TracksMap), "TrackingsMap");
+       TracksMap *map = MEM_callocN(sizeof(TracksMap), "TrackingsMap");
 
        BLI_strncpy(map->object_name, object_name, sizeof(map->object_name));
-       map->is_camera= is_camera;
+       map->is_camera = is_camera;
 
-       map->num_tracks= num_tracks;
-       map->customdata_size= customdata_size;
+       map->num_tracks = num_tracks;
+       map->customdata_size = customdata_size;
 
-       map->tracks= MEM_callocN(sizeof(MovieTrackingTrack)*num_tracks, "TrackingsMap tracks");
+       map->tracks = MEM_callocN(sizeof(MovieTrackingTrack)*num_tracks, "TrackingsMap tracks");
 
        if (customdata_size)
-               map->customdata= MEM_callocN(customdata_size*num_tracks, "TracksMap customdata");
+               map->customdata = MEM_callocN(customdata_size*num_tracks, "TracksMap customdata");
 
-       map->hash= BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "TracksMap hash");
+       map->hash = BLI_ghash_new(BLI_ghashutil_ptrhash, BLI_ghashutil_ptrcmp, "TracksMap hash");
 
        return map;
 }
@@ -735,19 +755,19 @@ static int tracks_map_size(TracksMap *map)
 
 static void tracks_map_get(TracksMap *map, int index, MovieTrackingTrack **track, void **customdata)
 {
-       *track= &map->tracks[index];
+       *track = &map->tracks[index];
 
        if (map->customdata)
-               *customdata= &map->customdata[index*map->customdata_size];
+               *customdata = &map->customdata[index*map->customdata_size];
 }
 
 static void tracks_map_insert(TracksMap *map, MovieTrackingTrack *track, void *customdata)
 {
        MovieTrackingTrack new_track= *track;
 
-       new_track.markers= MEM_dupallocN(new_track.markers);
+       new_track.markers = MEM_dupallocN(new_track.markers);
 
-       map->tracks[map->ptr]= new_track;
+       map->tracks[map->ptr] = new_track;
 
        if (customdata)
                memcpy(&map->customdata[map->ptr*map->customdata_size], customdata, map->customdata_size);
@@ -760,64 +780,64 @@ 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 *rot_track= tracking->stabilization.rot_track;
-       ListBase tracks= {NULL, NULL}, new_tracks= {NULL, NULL};
+       MovieTrackingTrack *act_track = BKE_tracking_active_track(tracking);
+       MovieTrackingTrack *rot_track = tracking->stabilization.rot_track;
+       ListBase tracks = {NULL, NULL}, new_tracks = {NULL, NULL};
        ListBase *old_tracks;
        int a;
 
        if (map->is_camera) {
-               old_tracks= &tracking->tracks;
+               old_tracks = &tracking->tracks;
        }
        else {
-               MovieTrackingObject *object= BKE_tracking_named_object(tracking, map->object_name);
+               MovieTrackingObject *object = BKE_tracking_named_object(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_new_object(tracking, map->object_name);
                }
 
-               old_tracks= &object->tracks;
+               old_tracks = &object->tracks;
        }
 
        /* duplicate currently operating tracks to temporary list.
         * this is needed to keep names in unique state and it's faster to change names
         * of currently operating tracks (if needed) */
-       for (a= 0; a<map->num_tracks; a++) {
-               int replace_sel= 0, replace_rot= 0;
+       for (a = 0; a < map->num_tracks; a++) {
+               int replace_sel = 0, replace_rot = 0;
                MovieTrackingTrack *new_track, *old;
 
-               track= &map->tracks[a];
+               track = &map->tracks[a];
 
                /* find original of operating track in list of previously displayed tracks */
-               old= BLI_ghash_lookup(map->hash, track);
+               old = BLI_ghash_lookup(map->hash, track);
                if (old) {
-                       MovieTrackingTrack *cur= old_tracks->first;
+                       MovieTrackingTrack *cur = old_tracks->first;
 
                        while (cur) {
-                               if (cur==old)
+                               if (cur == old)
                                        break;
 
-                               cur= cur->next;
+                               cur = cur->next;
                        }
 
                        /* original track was found, re-use flags and remove this track */
                        if (cur) {
-                               if (cur==act_track)
-                                       replace_sel= 1;
-                               if (cur==rot_track)
-                                       replace_rot= 1;
+                               if (cur == act_track)
+                                       replace_sel = 1;
+                               if (cur == rot_track)
+                                       replace_rot = 1;
 
-                               track->flag= cur->flag;
-                               track->pat_flag= cur->pat_flag;
-                               track->search_flag= cur->search_flag;
+                               track->flag = cur->flag;
+                               track->pat_flag = cur->pat_flag;
+                               track->search_flag = cur->search_flag;
 
                                BKE_tracking_free_track(cur);
                                BLI_freelinkN(old_tracks, cur);
                        }
                }
 
-               new_track= duplicate_track(track);
+               new_track = duplicate_track(track);
 
                BLI_ghash_remove(map->hash, track, NULL, NULL); /* XXX: are we actually need this */
                BLI_ghash_insert(map->hash, track, new_track);
@@ -832,24 +852,24 @@ static void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
        }
 
        /* move all tracks, which aren't operating */
-       track= old_tracks->first;
+       track = old_tracks->first;
        while (track) {
-               MovieTrackingTrack *next= track->next;
+               MovieTrackingTrack *next = track->next;
 
-               track->next= track->prev= NULL;
+               track->next = track->prev = NULL;
                BLI_addtail(&new_tracks, track);
 
                track= next;
        }
 
        /* now move all tracks which are currently operating and keep their names unique */
-       track= tracks.first;
+       track = tracks.first;
        while (track) {
-               MovieTrackingTrack *next= track->next;
+               MovieTrackingTrack *next = track->next;
 
                BLI_remlink(&tracks, track);
 
-               track->next= track->prev= NULL;
+               track->next = track->prev = NULL;
                BLI_addtail(&new_tracks, track);
 
                BLI_uniquename(&new_tracks, track, "Track", '.', offsetof(MovieTrackingTrack, name), sizeof(track->name));
@@ -866,7 +886,7 @@ static void tracks_map_free(TracksMap *map, void (*customdata_free) (void *custo
 
        BLI_ghash_free(map->hash, NULL, NULL);
 
-       for (i= 0; i<map->num_tracks; i++) {
+       for (i = 0; i < map->num_tracks; i++) {
                if (map->customdata && customdata_free)
                        customdata_free(&map->customdata[i*map->customdata_size]);
 
@@ -915,48 +935,48 @@ typedef struct MovieTrackingContext {
 
 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);
+       MovieTrackingContext *context = MEM_callocN(sizeof(MovieTrackingContext), "trackingContext");
+       MovieTracking *tracking = &clip->tracking;
+       MovieTrackingSettings *settings = &tracking->settings;
+       ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
        MovieTrackingTrack *track;
-       MovieTrackingObject *object= BKE_tracking_active_object(tracking);
-       int num_tracks= 0;
+       MovieTrackingObject *object = BKE_tracking_active_object(tracking);
+       int num_tracks = 0;
 
-       context->settings= *settings;
-       context->backwards= backwards;
-       context->sync_frame= user->framenr;
-       context->first_time= 1;
-       context->sequence= sequence;
+       context->settings = *settings;
+       context->backwards = backwards;
+       context->sync_frame = user->framenr;
+       context->first_time = TRUE;
+       context->sequence = sequence;
 
        /* count */
-       track= tracksbase->first;
+       track = tracksbase->first;
        while (track) {
                if (TRACK_SELECTED(track) && (track->flag & (TRACK_LOCKED | TRACK_HIDDEN))==0) {
-                       MovieTrackingMarker *marker= BKE_tracking_get_marker(track, user->framenr);
+                       MovieTrackingMarker *marker = BKE_tracking_get_marker(track, user->framenr);
 
-                       if ((marker->flag&MARKER_DISABLED)==0)
+                       if ((marker->flag & MARKER_DISABLED) == 0)
                                num_tracks++;
                }
 
-               track= track->next;
+               track = track->next;
        }
 
        if (num_tracks) {
                int width, height;
 
-               context->tracks_map= tracks_map_new(object->name, object->flag & TRACKING_OBJECT_CAMERA,
-                                       num_tracks, sizeof(TrackContext));
+               context->tracks_map = tracks_map_new(object->name, object->flag & TRACKING_OBJECT_CAMERA,
+                                                    num_tracks, sizeof(TrackContext));
 
                BKE_movieclip_get_size(clip, user, &width, &height);
 
                /* create tracking data */
-               track= tracksbase->first;
+               track = tracksbase->first;
                while (track) {
-                       if (TRACK_SELECTED(track) && (track->flag & (TRACK_HIDDEN | TRACK_LOCKED))==0) {
-                               MovieTrackingMarker *marker= BKE_tracking_get_marker(track, user->framenr);
+                       if (TRACK_SELECTED(track) && (track->flag & (TRACK_HIDDEN | TRACK_LOCKED)) == 0) {
+                               MovieTrackingMarker *marker = BKE_tracking_get_marker(track, user->framenr);
 
-                               if ((marker->flag&MARKER_DISABLED)==0) {
+                               if ((marker->flag & MARKER_DISABLED) == 0) {
                                        TrackContext track_context;
 
                                        memset(&track_context, 0, sizeof(TrackContext));
@@ -964,34 +984,39 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 #ifdef WITH_LIBMV
                                        {
                                                float patx, paty;
-                                               patx= (int)((track->pat_max[0]-track->pat_min[0])*width);
-                                               paty= (int)((track->pat_max[1]-track->pat_min[1])*height);
+                                               patx = (int)((track->pat_max[0]-track->pat_min[0])*width);
+                                               paty = (int)((track->pat_max[1]-track->pat_min[1])*height);
 
                                                if (ELEM(track->tracker, TRACKER_KLT, TRACKER_HYBRID)) {
-                                                       float search_size_x= (track->search_max[0]-track->search_min[0])*width;
-                                                       float search_size_y= (track->search_max[1]-track->search_min[1])*height;
-                                                       float pattern_size_x= (track->pat_max[0]-track->pat_min[0])*width;
-                                                       float pattern_size_y= (track->pat_max[1]-track->pat_min[1])*height;
-                                                       int wndx= (int)patx/2, wndy= (int)paty/2;
+                                                       float search_size_x = (track->search_max[0]-track->search_min[0])*width;
+                                                       float search_size_y = (track->search_max[1]-track->search_min[1])*height;
+                                                       float pattern_size_x = (track->pat_max[0]-track->pat_min[0])*width;
+                                                       float pattern_size_y = (track->pat_max[1]-track->pat_min[1])*height;
+                                                       int wndx = (int)patx / 2, wndy = (int)paty / 2;
+                                                       int half_wnd = MAX2(wndx, wndy);
 
                                                        /* compute the maximum pyramid size */
-                                                       float search_to_pattern_ratio= MIN2(search_size_x,  search_size_y)
+                                                       float search_to_pattern_ratio = MIN2(search_size_x,  search_size_y)
                                                                / MAX2(pattern_size_x, pattern_size_y);
                                                        float log2_search_to_pattern_ratio = log(floor(search_to_pattern_ratio)) / M_LN2;
-                                                       int max_pyramid_levels= floor(log2_search_to_pattern_ratio + 1);
+                                                       int max_pyramid_levels = floor(log2_search_to_pattern_ratio + 1);
 
                                                        /* try to accommodate the user's choice of pyramid level in a way
                                                         * that doesn't cause the coarsest pyramid pattern to be larger
                                                         * than the search size */
-                                                       int level= MIN2(track->pyramid_levels, max_pyramid_levels);
-
-                                                       if (track->tracker==TRACKER_KLT)
-                                                               track_context.region_tracker= libmv_pyramidRegionTrackerNew(100, level, MAX2(wndx, wndy), track->minimum_correlation);
-                                                       else
-                                                               track_context.region_tracker= libmv_hybridRegionTrackerNew(100, MAX2(wndx, wndy), track->minimum_correlation);
+                                                       int level = MIN2(track->pyramid_levels, max_pyramid_levels);
+
+                                                       if (track->tracker==TRACKER_KLT) {
+                                                               track_context.region_tracker =
+                                                                       libmv_pyramidRegionTrackerNew(100, level, half_wnd, track->minimum_correlation);
+                                                       }
+                                                       else {
+                                                               track_context.region_tracker =
+                                                                       libmv_hybridRegionTrackerNew(100, half_wnd, track->minimum_correlation);
+                                                       }
                                                }
-                                               else if (track->tracker==TRACKER_SAD) {
-                                                       track_context.pattern_size= MAX2(patx, paty);
+                                               else if (track->tracker == TRACKER_SAD) {
+                                                       track_context.pattern_size = MAX2(patx, paty);
                                                }
                                        }
 #endif
@@ -1000,11 +1025,11 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
                                }
                        }
 
-                       track= track->next;
+                       track = track->next;
                }
        }
 
-       context->clip= clip;
+       context->clip = clip;
 
        /* store needed clip flags passing to get_buffer functions
         * - MCLIP_USE_PROXY is needed to because timecode affects on movie clip
@@ -1014,11 +1039,11 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
         * - MCLIP_USE_PROXY_CUSTOM_DIR is needed because proxy/timecode files might
         *   be stored in a different location
         * ignore all the rest possible flags for now */
-       context->clip_flag= clip->flag&MCLIP_TIMECODE_FLAGS;
+       context->clip_flag = clip->flag&MCLIP_TIMECODE_FLAGS;
 
-       context->user= *user;
-       context->user.render_size= MCLIP_PROXY_RENDER_SIZE_FULL;
-       context->user.render_flag= 0;
+       context->user = *user;
+       context->user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL;
+       context->user.render_flag = 0;
 
        if (!sequence)
                BLI_begin_threaded_malloc();
@@ -1028,7 +1053,7 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
 
 static void track_context_free(void *customdata)
 {
-       TrackContext *track_context= (TrackContext *)customdata;
+       TrackContext *track_context = (TrackContext *)customdata;
 
 #if WITH_LIBMV
        if (track_context->region_tracker)
@@ -1074,17 +1099,19 @@ void BKE_tracking_disable_imbuf_channels(ImBuf *ibuf, int disable_red, int disab
                (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;
+       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 *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 {
@@ -1094,12 +1121,14 @@ void BKE_tracking_disable_imbuf_channels(ImBuf *ibuf, int disable_red, int disab
                                }
                        }
                        else {
-                               char *rrgb= (char*)ibuf->rect + pixel*4;
+                               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 {
@@ -1114,12 +1143,12 @@ void BKE_tracking_disable_imbuf_channels(ImBuf *ibuf, int disable_red, int disab
 
 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);
+       BKE_tracking_disable_imbuf_channels(ibuf, track->flag & TRACK_DISABLE_RED,
+                       track->flag & TRACK_DISABLE_GREEN, track->flag & TRACK_DISABLE_BLUE, grayscale);
 }
 
 static ImBuf *get_area_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                       float min[2], float max[2], int margin, int anchored, float pos[2], int origin[2])
+                             float min[2], float max[2], int margin, int anchored, float pos[2], int origin[2])
 {
        ImBuf *tmpibuf;
        int x, y;
@@ -1133,30 +1162,30 @@ static ImBuf *get_area_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTracki
        if (pos)
                zero_v2(pos);
 
-       x= mpos[0]*ibuf->x;
-       y= mpos[1]*ibuf->y;
+       x = mpos[0]*ibuf->x;
+       y = mpos[1]*ibuf->y;
 
-       w= (max[0]-min[0])*ibuf->x;
-       h= (max[1]-min[1])*ibuf->y;
+       w = (max[0] - min[0]) * ibuf->x;
+       h = (max[1] - min[1]) * ibuf->y;
 
        /* dimensions should be odd */
-       w= w|1;
-       h= h|1;
+       w = w|1;
+       h = h|1;
 
-       x1= x-(int)(w * (-min[0] / (max[0] - min[0])));
-       y1= y-(int)(h * (-min[1] / (max[1] - min[1])));
+       x1 = x-(int)(w * (-min[0] / (max[0] - min[0])));
+       y1 = y-(int)(h * (-min[1] / (max[1] - min[1])));
 
-       tmpibuf= IMB_allocImBuf(w+margin*2, h+margin*2, 32, IB_rect);
-       IMB_rectcpy(tmpibuf, ibuf, 0, 0, x1-margin, y1-margin, w+margin*2, h+margin*2);
+       tmpibuf = IMB_allocImBuf(w+margin*2, h+margin*2, 32, IB_rect);
+       IMB_rectcpy(tmpibuf, ibuf, 0, 0, x1 - margin, y1 - margin, w + margin * 2, h + margin * 2);
 
        if (pos != NULL) {
-               pos[0]= mpos[0]*ibuf->x-x1+margin;
-               pos[1]= mpos[1]*ibuf->y-y1+margin;
+               pos[0] = mpos[0] * ibuf->x - x1 + margin;
+               pos[1] = mpos[1] * ibuf->y - y1 + margin;
        }
 
        if (origin != NULL) {
-               origin[0]= x1-margin;
-               origin[1]= y1-margin;
+               origin[0] = x1 - margin;
+               origin[1] = y1 - margin;
        }
 
        if ((track->flag & TRACK_PREVIEW_GRAYSCALE) ||
@@ -1164,54 +1193,57 @@ static ImBuf *get_area_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTracki
           (track->flag & TRACK_DISABLE_GREEN)     ||
           (track->flag & TRACK_DISABLE_BLUE))
        {
-               disable_imbuf_channels(tmpibuf, track, 1 /* grayscale */);
+               disable_imbuf_channels(tmpibuf, track, TRUE /* grayscale */);
        }
 
        return tmpibuf;
 }
 
 ImBuf *BKE_tracking_get_pattern_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                       int margin, int anchored, float pos[2], int origin[2])
+                                      int margin, int anchored, float pos[2], int origin[2])
 {
        return get_area_imbuf(ibuf, track, marker, track->pat_min, track->pat_max, margin, anchored, pos, origin);
 }
 
 ImBuf *BKE_tracking_get_search_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                       int margin, int anchored, float pos[2], int origin[2])
+                                     int margin, int anchored, float pos[2], int origin[2])
 {
        return get_area_imbuf(ibuf, track, marker, track->search_min, track->search_max, margin, anchored, pos, origin);
 }
 
 #ifdef WITH_LIBMV
 static float *get_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                       int *width_r, int *height_r, float pos[2], int origin[2])
+                                  int *width_r, int *height_r, float pos[2], int origin[2])
 {
        ImBuf *tmpibuf;
        float *pixels, *fp;
        int x, y, width, height;
 
-       width= (track->search_max[0]-track->search_min[0])*ibuf->x;
-       height= (track->search_max[1]-track->search_min[1])*ibuf->y;
+       width = (track->search_max[0] - track->search_min[0]) * ibuf->x;
+       height = (track->search_max[1] - track->search_min[1]) * ibuf->y;
 
-       tmpibuf= BKE_tracking_get_search_imbuf(ibuf, track, marker, 0, 0, pos, origin);
-       disable_imbuf_channels(tmpibuf, track, 0 /* don't grayscale */);
+       tmpibuf = BKE_tracking_get_search_imbuf(ibuf, track, marker, 0, 0, pos, origin);
+       disable_imbuf_channels(tmpibuf, track, FALSE /* don't grayscale */);
 
-       *width_r= width;
-       *height_r= height;
+       *width_r = width;
+       *height_r = height;
 
-       fp= pixels= MEM_callocN(width*height*sizeof(float), "tracking floatBuf");
-       for (y= 0; y<(int)height; y++) {
-               for (x= 0; x<(int)width; x++) {
-                       int pixel= tmpibuf->x*y + x;
+       fp = pixels = MEM_callocN(width * height * sizeof(float), "tracking floatBuf");
+       for (y = 0; y < (int)height; y++) {
+               for (x = 0; x < (int)width; x++) {
+                       int pixel = tmpibuf->x * y + x;
 
                        if (tmpibuf->rect_float) {
-                               float *rrgbf= tmpibuf->rect_float + pixel*4;
-                               *fp= 0.2126*rrgbf[0] + 0.7152*rrgbf[1] + 0.0722*rrgbf[2];
+                               float *rrgbf = tmpibuf->rect_float + pixel * 4;
+
+                               *fp = 0.2126 * rrgbf[0] + 0.7152 * rrgbf[1] + 0.0722 * rrgbf[2];
                        }
                        else {
-                               unsigned char *rrgb= (unsigned char*)tmpibuf->rect + pixel*4;
-                               *fp= (0.2126*rrgb[0] + 0.7152*rrgb[1] + 0.0722*rrgb[2])/255.0f;
+                               unsigned char *rrgb = (unsigned char*)tmpibuf->rect + pixel * 4;
+
+                               *fp = (0.2126 * rrgb[0] + 0.7152 * rrgb[1] + 0.0722 * rrgb[2]) / 255.0f;
                        }
+
                        fp++;
                }
        }
@@ -1226,20 +1258,23 @@ 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;
+       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);
+                               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];
+                               const unsigned char *rrgb = (unsigned char*)ibuf->rect + pixel * 4;
+
+                               *cp = 0.2126f * rrgb[0] + 0.7152f * rrgb[1] + 0.0722f * rrgb[2];
                        }
+
                        cp++;
                }
        }
@@ -1248,18 +1283,18 @@ static unsigned char *get_ucharbuf(ImBuf *ibuf)
 }
 
 static unsigned char *get_search_bytebuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                       int *width_r, int *height_r, float pos[2], int origin[2])
+                                         int *width_r, int *height_r, float pos[2], int origin[2])
 {
        ImBuf *tmpibuf;
        unsigned char *pixels;
 
-       tmpibuf= BKE_tracking_get_search_imbuf(ibuf, track, marker, 0, 0, pos, origin);
-       disable_imbuf_channels(tmpibuf, track, 0 /* don't grayscale */);
+       tmpibuf = BKE_tracking_get_search_imbuf(ibuf, track, marker, 0, 0, pos, origin);
+       disable_imbuf_channels(tmpibuf, track, FALSE /* don't grayscale */);
 
-       *width_r= tmpibuf->x;
-       *height_r= tmpibuf->y;
+       *width_r = tmpibuf->x;
+       *height_r = tmpibuf->y;
 
-       pixels= get_ucharbuf(tmpibuf);
+       pixels = get_ucharbuf(tmpibuf);
 
        IMB_freeImBuf(tmpibuf);
 
@@ -1269,63 +1304,64 @@ static unsigned char *get_search_bytebuf(ImBuf *ibuf, MovieTrackingTrack *track,
 static ImBuf *get_frame_ibuf(MovieTrackingContext *context, int framenr)
 {
        ImBuf *ibuf;
-       MovieClipUser user= context->user;
+       MovieClipUser user = context->user;
 
-       user.framenr= framenr;
+       user.framenr = framenr;
 
-       ibuf= BKE_movieclip_get_ibuf_flag(context->clip, &user, context->clip_flag, MOVIECLIP_CACHE_SKIP);
+       ibuf = BKE_movieclip_get_ibuf_flag(context->clip, &user, context->clip_flag, MOVIECLIP_CACHE_SKIP);
 
        return ibuf;
 }
 
 static ImBuf *get_keyframed_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track,
-                       MovieTrackingMarker *marker, MovieTrackingMarker **marker_keyed)
+                                 MovieTrackingMarker *marker, MovieTrackingMarker **marker_keyed)
 {
-       int framenr= marker->framenr;
-       int a= marker-track->markers;
+       int framenr = marker->framenr;
+       int a = marker-track->markers;
 
-       *marker_keyed= marker;
+       *marker_keyed = marker;
 
-       while (a>=0 && a<track->markersnr) {
-               int next= (context->backwards) ? a+1 : a-1;
-               int is_keyframed= 0;
-               MovieTrackingMarker *cur_marker= &track->markers[a];
-               MovieTrackingMarker *next_marker= NULL;
+       while (a >= 0 && a < track->markersnr) {
+               int next = (context->backwards) ? a+1 : a-1;
+               int is_keyframed = FALSE;
+               MovieTrackingMarker *cur_marker = &track->markers[a];
+               MovieTrackingMarker *next_marker = NULL;
 
                if (next>=0 && next<track->markersnr)
                        next_marker= &track->markers[next];
 
                /* if next mrker is disabled, stop searching keyframe and use current frame as keyframe */
-               if (next_marker && next_marker->flag&MARKER_DISABLED)
-                       is_keyframed= 1;
+               if (next_marker && next_marker->flag & MARKER_DISABLED)
+                       is_keyframed = TRUE;
 
-               is_keyframed|= (cur_marker->flag&MARKER_TRACKED)==0;
+               is_keyframed |= (cur_marker->flag & MARKER_TRACKED) == 0;
 
                if (is_keyframed) {
-                       framenr= cur_marker->framenr;
-                       *marker_keyed= cur_marker;
+                       framenr = cur_marker->framenr;
+                       *marker_keyed = cur_marker;
+
                        break;
                }
 
-               a= next;
+               a = next;
        }
 
        return get_frame_ibuf(context, framenr);
 }
 
 static ImBuf *get_adjust_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                       int curfra, MovieTrackingMarker **marker_keyed)
+                              int curfra, MovieTrackingMarker **marker_keyed)
 {
-       ImBuf *ibuf= NULL;
+       ImBuf *ibuf = NULL;
 
        if (track->pattern_match == TRACK_MATCH_KEYFRAME) {
-               ibuf= get_keyframed_ibuf(context, track, marker, marker_keyed);
+               ibuf = get_keyframed_ibuf(context, track, marker, marker_keyed);
        }
        else {
-               ibuf= get_frame_ibuf(context, curfra);
+               ibuf = get_frame_ibuf(context, curfra);
 
                /* use current marker as keyframed position */
-               *marker_keyed= marker;
+               *marker_keyed = marker;
        }
 
        return ibuf;
@@ -1335,10 +1371,10 @@ static void get_warped(TrackContext *track_context, int x, int y, int width, uns
 {
        int i, j;
 
-       for (i=0; i<track_context->pattern_size; i++) {
-               for (j=0; j<track_context->pattern_size; j++) {
-                       track_context->warped[i*track_context->pattern_size+j]=
-                                       image[(y+i-track_context->pattern_size/2)*width+x+j-track_context->pattern_size/2];
+       for (i = 0; i < track_context->pattern_size; i++) {
+               for (j = 0; j < track_context->pattern_size; j++) {
+                       track_context->warped[i * track_context->pattern_size + j] =
+                                       image[(y + i - track_context->pattern_size / 2) * width + x + j - track_context->pattern_size / 2];
                }
        }
 }
@@ -1347,130 +1383,139 @@ static void get_warped(TrackContext *track_context, int x, int y, int width, uns
 
 void BKE_tracking_sync(MovieTrackingContext *context)
 {
-       MovieTracking *tracking= &context->clip->tracking;
+       MovieTracking *tracking = &context->clip->tracking;
        int newframe;
 
        tracks_map_merge(context->tracks_map, tracking);
 
-       if (context->backwards) newframe= context->user.framenr+1;
-       else newframe= context->user.framenr-1;
+       if (context->backwards)
+               newframe = context->user.framenr + 1;
+       else
+               newframe = context->user.framenr - 1;
 
-       context->sync_frame= newframe;
+       context->sync_frame = newframe;
 }
 
 void BKE_tracking_sync_user(MovieClipUser *user, MovieTrackingContext *context)
 {
-       user->framenr= context->sync_frame;
+       user->framenr = context->sync_frame;
 }
 
 int BKE_tracking_next(MovieTrackingContext *context)
 {
        ImBuf *ibuf_new;
-       int curfra= context->user.framenr;
-       int a, ok= 0, map_size;
+       int curfra = context->user.framenr;
+       int a, ok = FALSE, map_size;
 
-       map_size= tracks_map_size(context->tracks_map);
+       map_size = tracks_map_size(context->tracks_map);
 
        /* nothing to track, avoid unneeded frames reading to save time and memory */
        if (!map_size)
-               return 0;
+               return FALSE;
 
-       if (context->backwards) context->user.framenr--;
-       else context->user.framenr++;
+       if (context->backwards)
+               context->user.framenr--;
+       else
+               context->user.framenr++;
 
-       ibuf_new= BKE_movieclip_get_ibuf_flag(context->clip, &context->user, context->clip_flag, MOVIECLIP_CACHE_SKIP);
+       ibuf_new = BKE_movieclip_get_ibuf_flag(context->clip, &context->user, context->clip_flag, MOVIECLIP_CACHE_SKIP);
        if (!ibuf_new)
-               return 0;
+               return FALSE;
 
        #pragma omp parallel for private(a) shared(ibuf_new, ok) if (map_size>1)
-       for (a= 0; a<map_size; a++) {
+       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);
 
-               marker= BKE_tracking_exact_marker(track, curfra);
+               marker = BKE_tracking_exact_marker(track, curfra);
 
-               if (marker && (marker->flag&MARKER_DISABLED)==0) {
+               if (marker && (marker->flag & MARKER_DISABLED) == 0) {
 #ifdef WITH_LIBMV
-                       int width, height, origin[2], tracked= 0, need_readjust= 0;
+                       int width, height, origin[2], tracked = 0, need_readjust = 0;
                        float pos[2], margin[2], dim[2];
                        double x1, y1, x2, y2;
-                       ImBuf *ibuf= NULL;
+                       ImBuf *ibuf = NULL;
                        MovieTrackingMarker marker_new, *marker_keyed;
-                       int onbound= 0, nextfra;
+                       int onbound = FALSE, nextfra;
 
-                       if (track->pattern_match==TRACK_MATCH_KEYFRAME)
-                               need_readjust= context->first_time;
+                       if (track->pattern_match == TRACK_MATCH_KEYFRAME)
+                               need_readjust = context->first_time;
                        else
-                               need_readjust= 1;
+                               need_readjust = TRUE;
 
-                       if (context->backwards) nextfra= curfra-1;
-                       else nextfra= curfra+1;
+                       if (context->backwards)
+                               nextfra = curfra - 1;
+                       else
+                               nextfra = curfra + 1;
 
                        /* margin from frame boundaries */
                        sub_v2_v2v2(dim, track->pat_max, track->pat_min);
-                       margin[0]= margin[1]= MAX2(dim[0], dim[1]) / 2.0f;
+                       margin[0] = margin[1] = MAX2(dim[0], dim[1]) / 2.0f;
 
-                       margin[0]= MAX2(margin[0], (float)track->margin / ibuf_new->x);
-                       margin[1]= MAX2(margin[1], (float)track->margin / ibuf_new->y);
+                       margin[0] = MAX2(margin[0], (float)track->margin / ibuf_new->x);
+                       margin[1] = MAX2(margin[1], (float)track->margin / ibuf_new->y);
 
                        /* do not track markers which are too close to boundary */
                        if (marker->pos[0]<margin[0] || marker->pos[0]>1.0f-margin[0] ||
-                          marker->pos[1]<margin[1] || marker->pos[1]>1.0f-margin[1]) {
-                               onbound= 1;
+                           marker->pos[1]<margin[1] || marker->pos[1]>1.0f-margin[1])
+                       {
+                               onbound = TRUE;
                        }
                        else if (ELEM(track->tracker, TRACKER_KLT, TRACKER_HYBRID)) {
                                float *patch_new;
 
                                if (need_readjust) {
                                        /* calculate patch for keyframed position */
-                                       ibuf= get_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
+                                       ibuf = get_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
 
                                        if (track_context->patch)
                                                MEM_freeN(track_context->patch);
 
-                                       track_context->patch= get_search_floatbuf(ibuf, track, marker_keyed, &width, &height, track_context->keyframed_pos, origin);
+                                       track_context->patch = get_search_floatbuf(ibuf, track, marker_keyed, &width, &height,
+                                                                                  track_context->keyframed_pos, origin);
 
                                        IMB_freeImBuf(ibuf);
                                }
 
-                               patch_new= get_search_floatbuf(ibuf_new, track, marker, &width, &height, pos, origin);
+                               patch_new = get_search_floatbuf(ibuf_new, track, marker, &width, &height, pos, origin);
 
-                               x1= track_context->keyframed_pos[0];
-                               y1= track_context->keyframed_pos[1];
+                               x1 = track_context->keyframed_pos[0];
+                               y1 = track_context->keyframed_pos[1];
 
-                               x2= pos[0];
-                               y2= pos[1];
+                               x2 = pos[0];
+                               y2 = pos[1];
 
-                               tracked= libmv_regionTrackerTrack(track_context->region_tracker, track_context->patch, patch_new,
+                               tracked = libmv_regionTrackerTrack(track_context->region_tracker, track_context->patch, patch_new,
                                                        width, height, x1, y1, &x2, &y2);
 
                                MEM_freeN(patch_new);
                        }
-                       else if (track->tracker==TRACKER_SAD) {
+                       else if (track->tracker == TRACKER_SAD) {
                                unsigned char *image_new;
                                float correlation;
-                               float warp[3][2]={{0}};
+                               float warp[3][2] = {{0}};
 
                                if (need_readjust) {
                                        unsigned char *image;
 
                                        /* calculate pattern for keyframed position */
-                                       ibuf= get_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
+                                       ibuf = get_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
 
-                                       image= get_search_bytebuf(ibuf, track, marker_keyed, &width, &height, pos, origin);
+                                       image = get_search_bytebuf(ibuf, track, marker_keyed, &width, &height, pos, origin);
 
                                        memset(warp, 0, sizeof(warp));
-                                       warp[0][0]= 1;
-                                       warp[1][1]= 1;
-                                       warp[2][0]= pos[0];
-                                       warp[2][1]= pos[1];
+                                       warp[0][0] = 1;
+                                       warp[1][1] = 1;
+                                       warp[2][0] = pos[0];
+                                       warp[2][1] = pos[1];
 
                                        if (!track_context->pattern) {
-                                               int square= track_context->pattern_size*track_context->pattern_size;
-                                               track_context->pattern= MEM_callocN(sizeof(unsigned char)*square, "trackking pattern");
+                                               int square = track_context->pattern_size*track_context->pattern_size;
+
+                                               track_context->pattern = MEM_callocN(sizeof(unsigned char) * square, "trackking pattern");
                                        }
 
                                        libmv_SADSamplePattern(image, width, warp, track_context->pattern, track_context->pattern_size);
@@ -1479,37 +1524,39 @@ int BKE_tracking_next(MovieTrackingContext *context)
                                        IMB_freeImBuf(ibuf);
                                }
 
-                               image_new= get_search_bytebuf(ibuf_new, track, marker, &width, &height, pos, origin);
+                               image_new = get_search_bytebuf(ibuf_new, track, marker, &width, &height, pos, origin);
 
-                               if (track_context->warped==NULL) {
+                               if (track_context->warped == NULL) {
                                        unsigned char *image_old;
 
-                                       ibuf= get_frame_ibuf(context, curfra);
+                                       ibuf = get_frame_ibuf(context, curfra);
 
-                                       if (track_context->warped==NULL) {
-                                               int square= track_context->pattern_size*track_context->pattern_size;
-                                               track_context->warped= MEM_callocN(sizeof(unsigned char)*square, "trackking warped");
+                                       if (track_context->warped == NULL) {
+                                               int square = track_context->pattern_size * track_context->pattern_size;
+
+                                               track_context->warped = MEM_callocN(sizeof(unsigned char)*square, "trackking warped");
                                        }
 
-                                       image_old= get_search_bytebuf(ibuf, track, marker, &width, &height, pos, origin);
+                                       image_old = get_search_bytebuf(ibuf, track, marker, &width, &height, pos, origin);
                                        get_warped(track_context, pos[0], pos[1], width, image_old);
                                        IMB_freeImBuf(ibuf);
                                        MEM_freeN(image_old);
                                }
 
                                memset(warp, 0, sizeof(warp));
-                               warp[0][0]= 1;
-                               warp[1][1]= 1;
-                               warp[2][0]= pos[0];
-                               warp[2][1]= pos[1];
+                               warp[0][0] = 1;
+                               warp[1][1] = 1;
+                               warp[2][0] = pos[0];
+                               warp[2][1] = pos[1];
 
-                               correlation= libmv_SADTrackerTrack(track_context->pattern, track_context->warped,
-                                                       track_context->pattern_size, image_new, width, width, height, warp);
+                               correlation = libmv_SADTrackerTrack(track_context->pattern, track_context->warped,
+                                                                   track_context->pattern_size, image_new,
+                                                                   width, width, height, warp);
 
-                               x2= warp[2][0];
-                               y2= warp[2][1];
+                               x2 = warp[2][0];
+                               y2 = warp[2][1];
 
-                               tracked= track->minimum_correlation < correlation;
+                               tracked = track->minimum_correlation < correlation;
 
                                if (tracked)
                                        get_warped(track_context, x2, y2, width, image_new);
@@ -1530,14 +1577,14 @@ int BKE_tracking_next(MovieTrackingContext *context)
                                memset(&marker_new, 0, sizeof(marker_new));
 
                                if (!onbound) {
-                                       marker_new.pos[0]= (origin[0]+x2)/ibuf_new->x;
-                                       marker_new.pos[1]= (origin[1]+y2)/ibuf_new->y;
+                                       marker_new.pos[0] = (origin[0] + x2) / ibuf_new->x;
+                                       marker_new.pos[1] = (origin[1] + y2) / ibuf_new->y;
                                }
                                else {
                                        copy_v2_v2(marker_new.pos, marker->pos);
                                }
 
-                               marker_new.flag|= MARKER_TRACKED;
+                               marker_new.flag |= MARKER_TRACKED;
                                marker_new.framenr= nextfra;
 
                                #pragma omp critical
@@ -1552,10 +1599,10 @@ int BKE_tracking_next(MovieTrackingContext *context)
                                }
                        }
                        else {
-                               marker_new= *marker;
+                               marker_new = *marker;
 
-                               marker_new.framenr= nextfra;
-                               marker_new.flag|= MARKER_DISABLED;
+                               marker_new.framenr = nextfra;
+                               marker_new.flag |= MARKER_DISABLED;
 
                                #pragma omp critical
                                {
@@ -1563,14 +1610,14 @@ int BKE_tracking_next(MovieTrackingContext *context)
                                }
                        }
 
-                       ok= 1;
+                       ok = TRUE;
 #endif
                }
        }
 
        IMB_freeImBuf(ibuf_new);
 
-       context->first_time= 0;
+       context->first_time = FALSE;
        context->frames++;
 
        return ok;
@@ -1611,23 +1658,24 @@ typedef struct ReconstructProgressData {
 #if WITH_LIBMV
 static struct libmv_Tracks *create_libmv_tracks(ListBase *tracksbase, int width, int height)
 {
-       int tracknr= 0;
+       int tracknr = 0;
        MovieTrackingTrack *track;
-       struct libmv_Tracks *tracks= libmv_tracksNew();
+       struct libmv_Tracks *tracks = libmv_tracksNew();
 
-       track= tracksbase->first;
+       track = tracksbase->first;
        while (track) {
-               int a= 0;
+               int a = 0;
 
-               for (a= 0; a<track->markersnr; a++) {
-                       MovieTrackingMarker *marker= &track->markers[a];
+               for (a = 0; a < track->markersnr; a++) {
+                       MovieTrackingMarker *marker = &track->markers[a];
 
-                       if ((marker->flag&MARKER_DISABLED)==0)
+                       if ((marker->flag & MARKER_DISABLED) == 0) {
                                libmv_tracksInsert(tracks, marker->framenr, tracknr,
-                                                       marker->pos[0]*width, marker->pos[1]*height);
+                                                       marker->pos[0] * width, marker->pos[1] * height);
+                       }
                }
 
-               track= track->next;
+               track = track->next;
                tracknr++;
        }
 
@@ -1636,124 +1684,123 @@ static struct libmv_Tracks *create_libmv_tracks(ListBase *tracksbase, int width,
 
 static void retrieve_libmv_reconstruct_intrinscis(MovieReconstructContext *context, MovieTracking *tracking)
 {
-       struct libmv_Reconstruction *libmv_reconstruction= context->reconstruction;
+       struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
        struct libmv_CameraIntrinsics *libmv_intrinsics = libmv_ReconstructionExtractIntrinsics(libmv_reconstruction);
 
-       float aspy= 1.0f/tracking->camera.pixel_aspect;
+       float aspy = 1.0f / tracking->camera.pixel_aspect;
 
        double focal_length, principal_x, principal_y, k1, k2, k3;
        int width, height;
 
        libmv_CameraIntrinsicsExtract(libmv_intrinsics, &focal_length, &principal_x, &principal_y,
-                       &k1, &k2, &k3, &width, &height);
+                                     &k1, &k2, &k3, &width, &height);
 
-       tracking->camera.focal= focal_length;
-       tracking->camera.principal[0]= principal_x;
+       tracking->camera.focal = focal_length;
+       tracking->camera.principal[0] = principal_x;
 
-       /* todo: verify divide by aspy is correct */
-       tracking->camera.principal[1]= principal_y / aspy;
-       tracking->camera.k1= k1;
-       tracking->camera.k2= k2;
+       tracking->camera.principal[1] = principal_y / aspy;
+       tracking->camera.k1 = k1;
+       tracking->camera.k2 = k2;
 }
 
 static int retrieve_libmv_reconstruct_tracks(MovieReconstructContext *context, MovieTracking *tracking)
 {
-       struct libmv_Reconstruction *libmv_reconstruction= context->reconstruction;
-       MovieTrackingReconstruction *reconstruction= NULL;
+       struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
+       MovieTrackingReconstruction *reconstruction = NULL;
        MovieReconstructedCamera *reconstructed;
        MovieTrackingTrack *track;
-       ListBase *tracksbase=  NULL;
-       int ok= 1, tracknr= 0, a, origin_set= 0;
-       int sfra= context->sfra, efra= context->efra;
+       ListBase *tracksbase =  NULL;
+       int ok = TRUE, tracknr = 0, a, origin_set = FALSE;
+       int sfra = context->sfra, efra = context->efra;
        float imat[4][4];
 
        if (context->is_camera) {
-               tracksbase= &tracking->tracks;
-               reconstruction= &tracking->reconstruction;
+               tracksbase = &tracking->tracks;
+               reconstruction = &tracking->reconstruction;
        }
        else {
-               MovieTrackingObject *object= BKE_tracking_named_object(tracking, context->object_name);
+               MovieTrackingObject *object = BKE_tracking_named_object(tracking, context->object_name);
 
-               tracksbase= &object->tracks;
-               reconstruction= &object->reconstruction;
+               tracksbase = &object->tracks;
+               reconstruction = &object->reconstruction;
        }
 
        unit_m4(imat);
 
-       track= tracksbase->first;
+       track = tracksbase->first;
        while (track) {
                double pos[3];
 
                if (libmv_reporojectionPointForTrack(libmv_reconstruction, tracknr, pos)) {
-                       track->bundle_pos[0]= pos[0];
-                       track->bundle_pos[1]= pos[1];
-                       track->bundle_pos[2]= pos[2];
+                       track->bundle_pos[0] = pos[0];
+                       track->bundle_pos[1] = pos[1];
+                       track->bundle_pos[2] = pos[2];
 
-                       track->flag|= TRACK_HAS_BUNDLE;
-                       track->error= libmv_reporojectionErrorForTrack(libmv_reconstruction, tracknr);
+                       track->flag |= TRACK_HAS_BUNDLE;
+                       track->error = libmv_reporojectionErrorForTrack(libmv_reconstruction, tracknr);
                }
                else {
-                       track->flag&= ~TRACK_HAS_BUNDLE;
-                       ok= 0;
+                       track->flag &= ~TRACK_HAS_BUNDLE;
+                       ok = FALSE;
 
                        printf("No bundle for track #%d '%s'\n", tracknr, track->name);
                }
 
-               track= track->next;
+               track = track->next;
                tracknr++;
        }
 
        if (reconstruction->cameras)
                MEM_freeN(reconstruction->cameras);
 
-       reconstruction->camnr= 0;
-       reconstruction->cameras= NULL;
-       reconstructed= MEM_callocN((efra-sfra+1)*sizeof(MovieReconstructedCamera), "temp reconstructed camera");
+       reconstruction->camnr = 0;
+       reconstruction->cameras = NULL;
+       reconstructed = MEM_callocN((efra-sfra+1)*sizeof(MovieReconstructedCamera), "temp reconstructed camera");
 
-       for (a= sfra; a<=efra; a++) {
+       for (a = sfra; a <= efra; a++) {
                double matd[4][4];
 
                if (libmv_reporojectionCameraForImage(libmv_reconstruction, a, matd)) {
                        int i, j;
                        float mat[4][4];
-                       float error= libmv_reporojectionErrorForImage(libmv_reconstruction, a);
+                       float error = libmv_reporojectionErrorForImage(libmv_reconstruction, a);
 
-                       for (i=0; i<4; i++)
-                               for (j= 0; j<4; j++)
-                                       mat[i][j]= matd[i][j];
+                       for (i = 0; i < 4; i++)
+                               for (j = 0; j < 4; j++)
+                                       mat[i][j] = matd[i][j];
 
                        if (!origin_set) {
                                copy_m4_m4(imat, mat);
                                invert_m4(imat);
-                               origin_set= 1;
+                               origin_set = TRUE;
                        }
 
                        if (origin_set)
                                mult_m4_m4m4(mat, imat, mat);
 
                        copy_m4_m4(reconstructed[reconstruction->camnr].mat, mat);
-                       reconstructed[reconstruction->camnr].framenr= a;
-                       reconstructed[reconstruction->camnr].error= error;
+                       reconstructed[reconstruction->camnr].framenr = a;
+                       reconstructed[reconstruction->camnr].error = error;
                        reconstruction->camnr++;
                }
                else {
-                       ok= 0;
+                       ok = FALSE;
                        printf("No camera for frame %d\n", a);
                }
        }
 
        if (reconstruction->camnr) {
-               reconstruction->cameras= MEM_callocN(reconstruction->camnr*sizeof(MovieReconstructedCamera), "reconstructed camera");
-               memcpy(reconstruction->cameras, reconstructed, reconstruction->camnr*sizeof(MovieReconstructedCamera));
+               reconstruction->cameras = MEM_callocN(reconstruction->camnr * sizeof(MovieReconstructedCamera), "reconstructed camera");
+               memcpy(reconstruction->cameras, reconstructed, reconstruction->camnr * sizeof(MovieReconstructedCamera));
        }
 
        if (origin_set) {
-               track= tracksbase->first;
+               track = tracksbase->first;
                while (track) {
-                       if (track->flag&TRACK_HAS_BUNDLE)
+                       if (track->flag & TRACK_HAS_BUNDLE)
                                mul_v3_m4v3(track->bundle_pos, imat, track->bundle_pos);
 
-                       track= track->next;
+                       track = track->next;
                }
        }
 
@@ -1772,40 +1819,40 @@ static int retrieve_libmv_reconstruct(MovieReconstructContext *context, MovieTra
 
 static int get_refine_intrinsics_flags(MovieTracking *tracking, MovieTrackingObject *object)
 {
-       int refine= tracking->settings.refine_camera_intrinsics;
-       int flags= 0;
+       int refine = tracking->settings.refine_camera_intrinsics;
+       int flags = 0;
 
-       if ((object->flag&TRACKING_OBJECT_CAMERA)==0)
+       if ((object->flag & TRACKING_OBJECT_CAMERA) == 0)
                return 0;
 
-       if (refine&REFINE_FOCAL_LENGTH)
-               flags|= LIBMV_REFINE_FOCAL_LENGTH;
+       if (refine & REFINE_FOCAL_LENGTH)
+               flags |= LIBMV_REFINE_FOCAL_LENGTH;
 
-       if (refine&REFINE_PRINCIPAL_POINT)
-               flags|= LIBMV_REFINE_PRINCIPAL_POINT;
+       if (refine & REFINE_PRINCIPAL_POINT)
+               flags |= LIBMV_REFINE_PRINCIPAL_POINT;
 
-       if (refine&REFINE_RADIAL_DISTORTION_K1)
-               flags|= REFINE_RADIAL_DISTORTION_K1;
+       if (refine & REFINE_RADIAL_DISTORTION_K1)
+               flags |= REFINE_RADIAL_DISTORTION_K1;
 
-       if (refine&REFINE_RADIAL_DISTORTION_K2)
-               flags|= REFINE_RADIAL_DISTORTION_K2;
+       if (refine & REFINE_RADIAL_DISTORTION_K2)
+               flags |= REFINE_RADIAL_DISTORTION_K2;
 
        return flags;
 }
 
 static int count_tracks_on_both_keyframes(MovieTracking *tracking, ListBase *tracksbase)
 {
-       int tot= 0;
-       int frame1= tracking->settings.keyframe1, frame2= tracking->settings.keyframe2;
+       int tot = 0;
+       int frame1 = tracking->settings.keyframe1, frame2= tracking->settings.keyframe2;
        MovieTrackingTrack *track;
 
-       track= tracksbase->first;
+       track = tracksbase->first;
        while (track) {
                if (BKE_tracking_has_enabled_marker(track, frame1))
                        if (BKE_tracking_has_enabled_marker(track, frame2))
                                tot++;
 
-               track= track->next;
+               track = track->next;
        }
 
        return tot;
@@ -1815,76 +1862,78 @@ static int count_tracks_on_both_keyframes(MovieTracking *tracking, ListBase *tra
 int BKE_tracking_can_reconstruct(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_tracks(tracking, object);
 
        if (count_tracks_on_both_keyframes(tracking, tracksbase)<8) {
                BLI_strncpy(error_msg, "At least 8 common tracks on both of keyframes are needed for reconstruction", error_size);
-               return 0;
+
+               return FALSE;
        }
 
-       return 1;
+       return TRUE;
 #else
        BLI_strncpy(error_msg, "Blender is compiled without motion tracking library", error_size);
-       (void)tracking;
-       (void)object;
+
+       (void) tracking;
+       (void) object;
 
        return 0;
 #endif
 }
 
-MovieReconstructContext* BKE_tracking_reconstruction_context_new(MovieTracking *tracking,
-                       MovieTrackingObject *object, int keyframe1, int keyframe2, int width, int height)
+MovieReconstructContext* BKE_tracking_reconstruction_context_new(MovieTracking *tracking, MovieTrackingObject *object,
+                                                                 int keyframe1, int keyframe2, int width, int height)
 {
-       MovieReconstructContext *context= MEM_callocN(sizeof(MovieReconstructContext), "MovieReconstructContext data");
-       MovieTrackingCamera *camera= &tracking->camera;
-       ListBase *tracksbase= BKE_tracking_object_tracks(tracking, object);
-       float aspy= 1.0f/tracking->camera.pixel_aspect;
-       int num_tracks= BLI_countlist(tracksbase);
-       int sfra= INT_MAX, efra= INT_MIN;
+       MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext), "MovieReconstructContext data");
+       MovieTrackingCamera *camera = &tracking->camera;
+       ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
+       float aspy = 1.0f / tracking->camera.pixel_aspect;
+       int num_tracks = BLI_countlist(tracksbase);
+       int sfra = INT_MAX, efra = INT_MIN;
        MovieTrackingTrack *track;
 
        BLI_strncpy(context->object_name, object->name, sizeof(context->object_name));
        context->is_camera = object->flag&TRACKING_OBJECT_CAMERA;
 
-       context->tracks_map= tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
+       context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
 
-       track= tracksbase->first;
+       track = tracksbase->first;
        while (track) {
-               int first= 0, last= track->markersnr-1;
-               MovieTrackingMarker *first_marker= &track->markers[0];
-               MovieTrackingMarker *last_marker= &track->markers[track->markersnr-1];
+               int first = 0, last = track->markersnr-1;
+               MovieTrackingMarker *first_marker = &track->markers[0];
+               MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1];
 
                /* find first not-disabled marker */
-               while (first<=track->markersnr-1 && first_marker->flag&MARKER_DISABLED) {
+               while (first <= track->markersnr - 1 && first_marker->flag & MARKER_DISABLED) {
                        first++;
                        first_marker++;
                }
 
                /* find last not-disabled marker */
-               while (last>=0 && last_marker->flag&MARKER_DISABLED) {
+               while (last >= 0 && last_marker->flag & MARKER_DISABLED) {
                        last--;
                        last_marker--;
                }
 
-               if (first<track->markersnr-1)
-                       sfra= MIN2(sfra, first_marker->framenr);
+               if (first<track->markersnr - 1)
+                       sfra = MIN2(sfra, first_marker->framenr);
 
-               if (last>=0)
-                       efra= MAX2(efra, last_marker->framenr);
+               if (last >= 0)
+                       efra = MAX2(efra, last_marker->framenr);
 
                tracks_map_insert(context->tracks_map, track, NULL);
 
-               track= track->next;
+               track = track->next;
        }
 
-       context->sfra= sfra;
-       context->efra= efra;
+       context->sfra = sfra;
+       context->efra = efra;
 
 #ifdef WITH_LIBMV
-       context->tracks= create_libmv_tracks(tracksbase, width, height*aspy);
-       context->keyframe1= keyframe1;
-       context->keyframe2= keyframe2;
-       context->refine_flags= get_refine_intrinsics_flags(tracking, object);
+       context->tracks = create_libmv_tracks(tracksbase, width, height*aspy);
+       context->keyframe1 = keyframe1;
+       context->keyframe2 = keyframe2;
+       context->refine_flags = get_refine_intrinsics_flags(tracking, object);
 #else
        (void) width;
        (void) height;
@@ -1892,13 +1941,13 @@ 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->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->k1 = camera->k1;
+       context->k2 = camera->k2;
+       context->k3 = camera->k3;
 
        return context;
 }
@@ -1923,40 +1972,39 @@ static void solve_reconstruction_update_cb(void *customdata, double progress, co
        ReconstructProgressData *progressdata= customdata;
 
        if (progressdata->progress) {
-               *progressdata->progress= progress;
-               *progressdata->do_update= 1;
+               *progressdata->progress = progress;
+               *progressdata->do_update = TRUE;
        }
 
-       BLI_snprintf(progressdata->stats_message, progressdata->message_size,
-                       "Solving camera | %s", message);
+       BLI_snprintf(progressdata->stats_message, progressdata->message_size, "Solving camera | %s", message);
 }
 #endif
 
 #if 0
 static int solve_reconstruction_testbreak_cb(void *customdata)
 {
-       ReconstructProgressData *progressdata= customdata;
+       ReconstructProgressData *progressdata = customdata;
 
        if (progressdata->stop && *progressdata->stop)
-               return 1;
+               return TRUE;
 
        return G.afbreek;
 }
 #endif
 
-void BKE_tracking_solve_reconstruction(MovieReconstructContext *context, short *stop,
-                       short *do_update, float *progress, char *stats_message, int message_size)
+void BKE_tracking_solve_reconstruction(MovieReconstructContext *context, short *stop, short *do_update,
+                                       float *progress, char *stats_message, int message_size)
 {
 #ifdef WITH_LIBMV
        float error;
 
        ReconstructProgressData progressdata;
 
-       progressdata.stop= stop;
-       progressdata.do_update= do_update;
-       progressdata.progress= progress;
-       progressdata.stats_message= stats_message;
-       progressdata.message_size= message_size;
+       progressdata.stop = stop;
+       progressdata.do_update = do_update;
+       progressdata.progress = progress;
+       progressdata.stats_message = stats_message;
+       progressdata.message_size = message_size;
 
        context->reconstruction = libmv_solveReconstruction(context->tracks,
                context->keyframe1, context->keyframe2,
@@ -1966,9 +2014,9 @@ void BKE_tracking_solve_reconstruction(MovieReconstructContext *context, short *
                context->k1, context->k2, context->k3,
                solve_reconstruction_update_cb, &progressdata);
 
-       error= libmv_reprojectionError(context->reconstruction);
+       error = libmv_reprojectionError(context->reconstruction);
 
-       context->reprojection_error= error;
+       context->reprojection_error = error;
 #else
        (void) context;
        (void) stop;
@@ -1986,24 +2034,24 @@ int BKE_tracking_finish_reconstruction(MovieReconstructContext *context, MovieTr
        tracks_map_merge(context->tracks_map, tracking);
 
        if (context->is_camera) {
-               reconstruction= &tracking->reconstruction;
+               reconstruction = &tracking->reconstruction;
        }
        else {
                MovieTrackingObject *object;
 
-               object= BKE_tracking_named_object(tracking, context->object_name);
-               reconstruction= &object->reconstruction;
+               object = BKE_tracking_named_object(tracking, context->object_name);
+               reconstruction = &object->reconstruction;
        }
 
-       reconstruction->error= context->reprojection_error;
-       reconstruction->flag|= TRACKING_RECONSTRUCTED;
+       reconstruction->error = context->reprojection_error;
+       reconstruction->flag |= TRACKING_RECONSTRUCTED;
 
 #ifdef WITH_LIBMV
        if (!retrieve_libmv_reconstruct(context, tracking))
-               return 0;
+               return FALSE;
 #endif
 
-       return 1;
+       return TRUE;
 }
 
 void BKE_track_unique_name(ListBase *tracksbase, MovieTrackingTrack *track)
@@ -2013,14 +2061,14 @@ void BKE_track_unique_name(ListBase *tracksbase, MovieTrackingTrack *track)
 
 MovieTrackingTrack *BKE_tracking_named_track(MovieTracking *tracking, MovieTrackingObject *object, const char *name)
 {
-       ListBase *tracksbase= BKE_tracking_object_tracks(tracking, object);
-       MovieTrackingTrack *track= tracksbase->first;
+       ListBase *tracksbase = BKE_tracking_object_tracks(tracking, object);
+       MovieTrackingTrack *track = tracksbase->first;
 
        while (track) {
                if (!strcmp(track->name, name))
                        return track;
 
-               track= track->next;
+               track = track->next;
        }
 
        return NULL;
@@ -2029,51 +2077,59 @@ MovieTrackingTrack *BKE_tracking_named_track(MovieTracking *tracking, MovieTrack
 static int reconstruction_camera_index(MovieTrackingReconstruction *reconstruction, int framenr, int nearest)
 {
        MovieReconstructedCamera *cameras= reconstruction->cameras;
-       int a= 0, d= 1;
+       int a = 0, d = 1;
 
        if (!reconstruction->camnr)
                return -1;
 
        if (framenr<cameras[0].framenr) {
-               if (nearest) return 0;
-               else return -1;
+               if (nearest)
+                       return 0;
+               else
+                       return -1;
        }
 
-       if (framenr>cameras[reconstruction->camnr-1].framenr) {
-               if (nearest) return reconstruction->camnr-1;
-               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;
+               a = reconstruction->last_camera;
 
-       if (cameras[a].framenr>=framenr)
-               d= -1;
+       if (cameras[a].framenr >= framenr)
+               d = -1;
 
-       while (a>=0 && a<reconstruction->camnr) {
-               int cfra= cameras[a].framenr;
+       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) {
+               if (d > 0 && cfra > framenr) {
                        /* interpolate with previous position */
-                       if (nearest) return a-1;
-                       else break;
+                       if (nearest)
+                               return a - 1;
+                       else
+                               break;
                }
 
-               if (d<0 && cfra<framenr) {
+               if (d < 0 && cfra < framenr) {
                        /* interpolate with next position */
-                       if (nearest) return a;
-                       else break;
+                       if (nearest)
+                               return a;
+                       else
+                               break;
                }
 
-               if (cfra==framenr) {
-                       reconstruction->last_camera= a;
+               if (cfra == framenr) {
+                       reconstruction->last_camera = a;
 
                        return a;
                }
 
-               a+= d;
+               a += d;
        }
 
        return -1;
@@ -2081,47 +2137,48 @@ static int reconstruction_camera_index(MovieTrackingReconstruction *reconstructi
 
 static void scale_reconstructed_camera(MovieTrackingObject *object, float mat[4][4])
 {
-       if ((object->flag&TRACKING_OBJECT_CAMERA)==0) {
+       if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) {
                float smat[4][4];
 
-               scale_m4_fl(smat, 1.0f/object->scale);
+               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)
+                                                                MovieTrackingObject *object, int framenr)
 {
        MovieTrackingReconstruction *reconstruction;
        int a;
 
-       reconstruction= BKE_tracking_object_reconstruction(tracking, object);
-       a= reconstruction_camera_index(reconstruction, framenr, 0);
+       reconstruction = BKE_tracking_object_reconstruction(tracking, object);
+       a = reconstruction_camera_index(reconstruction, framenr, FALSE);
 
-       if (a==-1)
+       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])
+                                          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);
+       reconstruction = BKE_tracking_object_reconstruction(tracking, object);
+       cameras = reconstruction->cameras;
+       a = reconstruction_camera_index(reconstruction, framenr, 1);
 
-       if (a==-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);
+       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);
        }
@@ -2135,8 +2192,10 @@ void BKE_tracking_get_interpolated_camera(MovieTracking *tracking, MovieTracking
 void BKE_get_tracking_mat(Scene *scene, Object *ob, float mat[4][4])
 {
        if (!ob) {
-               if (scene->camera) ob= scene->camera;
-               else ob= scene_find_camera(scene);
+               if (scene->camera)
+                       ob = scene->camera;
+               else
+                       ob = scene_find_camera(scene);
        }
 
        if (ob)
@@ -2147,53 +2206,54 @@ void BKE_get_tracking_mat(Scene *scene, Object *ob, float mat[4][4])
 
 void BKE_tracking_camera_shift(MovieTracking *tracking, int winx, int winy, float *shiftx, float *shifty)
 {
-       *shiftx= (0.5f*winx-tracking->camera.principal[0]) / winx;
-       *shifty= (0.5f*winy-tracking->camera.principal[1]) / winx;
+       /* 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;
+       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;
+       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.xsch = width*tracking->camera.pixel_aspect;
+       scene->r.ysch = height;
 
-       scene->r.xasp= 1.0f;
-       scene->r.yasp= 1.0f;
+       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])
+                                    int framenr, int winx, int winy, float mat[4][4])
 {
        MovieReconstructedCamera *camera;
-       float lens= tracking->camera.focal*tracking->camera.sensor_width/(float)winx;
+       float lens = tracking->camera.focal*tracking->camera.sensor_width/(float)winx;
        float viewfac, pixsize, left, right, bottom, top, clipsta, clipend;
        float winmat[4][4];
-       float ycor= 1.0f/tracking->camera.pixel_aspect;
-       float shiftx, shifty, winside= MAX2(winx, winy);
+       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;
+       clipsta = 0.1f;
+       clipend = 1000.0f;
 
        if (winx >= winy)
-               viewfac= (lens*winx)/tracking->camera.sensor_width;
+               viewfac = (lens*winx)/tracking->camera.sensor_width;
        else
-               viewfac= (ycor*lens*winy)/tracking->camera.sensor_width;
+               viewfac = (ycor*lens*winy)/tracking->camera.sensor_width;
 
-       pixsize= clipsta/viewfac;
+       pixsize = clipsta/viewfac;
 
-       left= -0.5f*(float)winx + shiftx*winside;
-       bottom= -0.5f*(ycor)*(float)winy + shifty*winside;
-       right=  0.5f*(float)winx + shiftx*winside;
-       top=  0.5f*(ycor)*(float)winy + shifty*winside;
+       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;
@@ -2202,7 +2262,7 @@ void BKE_tracking_projection_matrix(MovieTracking *tracking, MovieTrackingObject
 
        perspective_m4(winmat, left, right, bottom, top, clipsta, clipend);
 
-       camera= BKE_tracking_get_reconstructed_camera(tracking, object, framenr);
+       camera = BKE_tracking_get_reconstructed_camera(tracking, object, framenr);
 
        if (camera) {
                float imat[4][4];
@@ -2215,7 +2275,7 @@ void BKE_tracking_projection_matrix(MovieTracking *tracking, MovieTrackingObject
 
 ListBase *BKE_tracking_get_tracks(MovieTracking *tracking)
 {
-       MovieTrackingObject *object= BKE_tracking_active_object(tracking);
+       MovieTrackingObject *object = BKE_tracking_active_object(tracking);
 
        if (object && (object->flag & TRACKING_OBJECT_CAMERA) == 0) {
                return &object->tracks;
@@ -2231,7 +2291,7 @@ MovieTrackingTrack *BKE_tracking_active_track(MovieTracking *tracking)
        if (!tracking->act_track)
                return NULL;
 
-       tracksbase= BKE_tracking_get_tracks(tracking);
+       tracksbase = BKE_tracking_get_tracks(tracking);
 
        /* check that active track is in current tracks list */
        if (BLI_findindex(tracksbase, tracking->act_track) >= 0)
@@ -2247,7 +2307,7 @@ MovieTrackingObject *BKE_tracking_active_object(MovieTracking *tracking)
 
 MovieTrackingObject *BKE_tracking_get_camera_object(MovieTracking *tracking)
 {
-       MovieTrackingObject *object= tracking->objects.first;
+       MovieTrackingObject *object = tracking->objects.first;
 
        while (object) {
                if (object->flag & TRACKING_OBJECT_CAMERA)
@@ -2279,7 +2339,7 @@ MovieTrackingReconstruction *BKE_tracking_object_reconstruction(MovieTracking *t
 
 MovieTrackingReconstruction *BKE_tracking_get_reconstruction(MovieTracking *tracking)
 {
-       MovieTrackingObject *object= BKE_tracking_active_object(tracking);
+       MovieTrackingObject *object = BKE_tracking_active_object(tracking);
 
        return BKE_tracking_object_reconstruction(tracking, object);
 }
@@ -2290,42 +2350,42 @@ void BKE_tracking_apply_intrinsics(MovieTracking *tracking, float co[2], float n
 
 #ifdef WITH_LIBMV
        double x, y;
-       float aspy= 1.0f/tracking->camera.pixel_aspect;
+       float aspy = 1.0f/tracking->camera.pixel_aspect;
 
        /* normalize coords */
-       x= (co[0]-camera->principal[0]) / camera->focal;
-       y= (co[1]-camera->principal[1] * aspy) / camera->focal;
+       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);
+                                   camera->k1, camera->k2, camera->k3, x, y, &x, &y);
 
        /* result is in image coords already */
-       nco[0]= x;
-       nco[1]= y;
+       nco[0] = x;
+       nco[1] = y;
 #else
-       (void)camera;
-       (void)co;
-       (void)nco;
+       (void) camera;
+       (void) co;
+       (void) nco;
 #endif
 }
 
 void BKE_tracking_invert_intrinsics(MovieTracking *tracking, float co[2], float nco[2])
 {
-       MovieTrackingCamera *camera= &tracking->camera;
+       MovieTrackingCamera *camera = &tracking->camera;
 
 #ifdef WITH_LIBMV
-       double x= co[0], y= co[1];
-       float aspy= 1.0f/tracking->camera.pixel_aspect;
+       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);
+                              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;
+       nco[0] = x * camera->focal + camera->principal[0];
+       nco[1] = y * camera->focal + camera->principal[1] * aspy;
 #else
-       (void)camera;
-       (void)co;
-       (void)nco;
+       (void) camera;
+       (void) co;
+       (void) nco;
 #endif
 }
 
@@ -2333,125 +2393,126 @@ void BKE_tracking_invert_intrinsics(MovieTracking *tracking, float co[2], float
 static int point_in_stroke(bGPDstroke *stroke, float x, float y)
 {
        int i, prev;
-       int count= 0;
-       bGPDspoint *points= stroke->points;
+       int count = 0;
+       bGPDspoint *points = stroke->points;
 
-       prev= stroke->totpoints-1;
+       prev = stroke->totpoints - 1;
 
-       for (i= 0; i<stroke->totpoints; i++) {
-               if ((points[i].y<y && points[prev].y>=y) || (points[prev].y<y && points[i].y>=y)) {
-                       float fac= (y-points[i].y)/(points[prev].y-points[i].y);
+       for (i = 0; i<stroke->totpoints; i++) {
+               if ((points[i].y < y && points[prev].y >= y) || (points[prev].y < y && points[i].y >= y)) {
+                       float fac = (y - points[i].y) / (points[prev].y - points[i].y);
 
-                       if (points[i].x+fac*(points[prev].x-points[i].x)<x)
+                       if (points[i].x + fac * (points[prev].x - points[i].x) < x)
                                count++;
                }
 
                prev= i;
        }
 
-       return count%2;
+       return count % 2;
 }
 
 static int point_in_layer(bGPDlayer *layer, float x, float y)
 {
-       bGPDframe *frame= layer->frames.first;
+       bGPDframe *frame = layer->frames.first;
 
        while (frame) {
-               bGPDstroke *stroke= frame->strokes.first;
+               bGPDstroke *stroke = frame->strokes.first;
+
                while (stroke) {
                        if (point_in_stroke(stroke, x, y))
-                               return 1;
+                               return TRUE;
 
-                       stroke= stroke->next;
+                       stroke = stroke->next;
                }
-               frame= frame->next;
+               frame = frame->next;
        }
 
-       return 0;
+       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)
+                                    struct libmv_Features *features, int framenr, int width, int height,
+                                    bGPDlayer *layer, int place_outside_layer)
 {
        int a;
 
-       a= libmv_countFeatures(features);
+       a = libmv_countFeatures(features);
        while (a--) {
                MovieTrackingTrack *track;
                double x, y, size, score;
-               int ok= 1;
+               int ok = TRUE;
                float xu, yu;
 
                libmv_getFeature(features, a, &x, &y, &score, &size);
 
-               xu= x/width;
-               yu= y/height;
+               xu = x / width;
+               yu = y / height;
 
                if (layer)
-                       ok= point_in_layer(layer, xu, yu)!=place_outside_layer;
+                       ok = point_in_layer(layer, xu, yu) != place_outside_layer;
 
                if (ok) {
-                       track= BKE_tracking_add_track(tracking, tracksbase, xu, yu, framenr, width, height);
-                       track->flag|= SELECT;
-                       track->pat_flag|= SELECT;
-                       track->search_flag|= SELECT;
+                       track = BKE_tracking_add_track(tracking, tracksbase, xu, yu, framenr, width, height);
+                       track->flag |= SELECT;
+                       track->pat_flag |= SELECT;
+                       track->search_flag |= SELECT;
                }
        }
 }
 #endif
 
 void BKE_tracking_detect_fast(MovieTracking *tracking, ListBase *tracksbase, ImBuf *ibuf,
-                       int framenr, int margin, int min_trackness, int min_distance, bGPDlayer *layer,
-                       int place_outside_layer)
+                              int framenr, int margin, int min_trackness, int min_distance, bGPDlayer *layer,
+                              int place_outside_layer)
 {
 #ifdef WITH_LIBMV
        struct libmv_Features *features;
-       unsigned char *pixels= get_ucharbuf(ibuf);
+       unsigned char *pixels = get_ucharbuf(ibuf);
 
-       features= libmv_detectFeaturesFAST(pixels, ibuf->x, ibuf->y, ibuf->x,
-                       margin, min_trackness, min_distance);
+       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,
-                       ibuf->x, ibuf->y, layer, place_outside_layer);
+                               ibuf->x, ibuf->y, layer, place_outside_layer);
 
        libmv_destroyFeatures(features);
 #else
-       (void)tracking;
-       (void)tracksbase;
-       (void)ibuf;
-       (void)framenr;
-       (void)margin;
-       (void)min_trackness;
-       (void)min_distance;
-       (void)layer;
-       (void)place_outside_layer;
+       (void) tracking;
+       (void) tracksbase;
+       (void) ibuf;
+       (void) framenr;
+       (void) margin;
+       (void) min_trackness;
+       (void) min_distance;
+       (void) layer;
+       (void) place_outside_layer;
 #endif
 }
 
 MovieTrackingTrack *BKE_tracking_indexed_track(MovieTracking *tracking, int tracknr, ListBase **tracksbase_r)
 {
        MovieTrackingObject *object;
-       int cur= 1;
+       int cur = 1;
 
-       object= tracking->objects.first;
+       object = tracking->objects.first;
        while (object) {
-               ListBase *tracksbase= BKE_tracking_object_tracks(tracking, object);
-               MovieTrackingTrack *track= tracksbase->first;
+               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;
+                       if (track->flag & TRACK_HAS_BUNDLE) {
+                               if (cur == tracknr) {
+                                       *tracksbase_r = tracksbase;
                                        return track;
                                }
 
                                cur++;
                        }
 
-                       track= track->next;
+                       track = track->next;
                }
 
                object= object->next;
@@ -2464,104 +2525,103 @@ MovieTrackingTrack *BKE_tracking_indexed_track(MovieTracking *tracking, int trac
 
 static int stabilization_median_point(MovieTracking *tracking, int framenr, float median[2])
 {
-       int ok= 0;
+       int ok = FALSE;
        float min[2], max[2];
        MovieTrackingTrack *track;
 
        INIT_MINMAX2(min, max);
 
-       (void) tracking;
-
-       track= tracking->tracks.first;
+       track = tracking->tracks.first;
        while (track) {
-               if (track->flag&TRACK_USE_2D_STAB) {
-                       MovieTrackingMarker *marker= BKE_tracking_get_marker(track, framenr);
+               if (track->flag & TRACK_USE_2D_STAB) {
+                       MovieTrackingMarker *marker = BKE_tracking_get_marker(track, framenr);
 
                        DO_MINMAX2(marker->pos, min, max);
 
-                       ok= 1;
+                       ok = TRUE;
                }
 
-               track= track->next;
+               track = track->next;
        }
 
-       median[0]= (max[0]+min[0])/2.0f;
-       median[1]= (max[1]+min[1])/2.0f;
+       median[0] = (max[0] + min[0]) / 2.0f;
+       median[1] = (max[1] + min[1]) / 2.0f;
 
        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)
+                               float firstmedian[2], float median[2], float loc[2], float *scale, float *angle)
 {
-       MovieTrackingStabilization *stab= &tracking->stabilization;
+       MovieTrackingStabilization *stab = &tracking->stabilization;
 
-       *scale= (stab->scale-1.0f)*stab->scaleinf+1.0f;
-       *angle= 0.0f;
+       *scale = (stab->scale - 1.0f) * stab->scaleinf + 1.0f;
+       *angle = 0.0f;
 
-       loc[0]= (firstmedian[0]-median[0])*width*(*scale);
-       loc[1]= (firstmedian[1]-median[1])*height*(*scale);
+       loc[0] = (firstmedian[0] - median[0]) *width * (*scale);
+       loc[1] = (firstmedian[1] - median[1]) *height * (*scale);
 
        mul_v2_fl(loc, stab->locinf);
 
-       if ((stab->flag&TRACKING_STABILIZE_ROTATION) && stab->rot_track && stab->rotinf) {
+       if ((stab->flag & TRACKING_STABILIZE_ROTATION) && stab->rot_track && stab->rotinf) {
                MovieTrackingMarker *marker;
                float a[2], b[2];
-               float x0= (float)width/2.0f, y0= (float)height/2.0f;
-               float x= median[0]*width, y= median[1]*height;
+               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_get_marker(stab->rot_track, 1);
                sub_v2_v2v2(a, marker->pos, firstmedian);
-               a[0]*= width;
-               a[1]*= height;
+               a[0] *= width;
+               a[1] *= height;
 
-               marker= BKE_tracking_get_marker(stab->rot_track, framenr);
+               marker = BKE_tracking_get_marker(stab->rot_track, framenr);
                sub_v2_v2v2(b, marker->pos, median);
-               b[0]*= width;
-               b[1]*= height;
+               b[0] *= width;
+               b[1] *= height;
 
-               *angle= -atan2(a[0]*b[1]-a[1]*b[0], a[0]*b[0]+a[1]*b[1]);
-               *angle*= stab->rotinf;
+               *angle = -atan2(a[0]*b[1]-a[1]*b[0], a[0]*b[0]+a[1]*b[1]);
+               *angle *= stab->rotinf;
 
                /* convert to rotation around image center */
-               loc[0]-= (x0 + (x-x0)*cosf(*angle)-(y-y0)*sinf(*angle) - x)*(*scale);
-               loc[1]-= (y0 + (x-x0)*sinf(*angle)+(y-y0)*cosf(*angle) - y)*(*scale);
+               loc[0] -= (x0 + (x - x0) * cosf(*angle) - (y - y0) * sinf(*angle) - x) * (*scale);
+               loc[1] -= (y0 + (x - x0) * sinf(*angle) + (y - y0) * cosf(*angle) - y) * (*scale);
        }
 }
 
 static float stabilization_auto_scale_factor(MovieTracking *tracking, int width, int height)
 {
        float firstmedian[2];
-       MovieTrackingStabilization *stab= &tracking->stabilization;
-       float aspect= tracking->camera.pixel_aspect;
+       MovieTrackingStabilization *stab = &tracking->stabilization;
+       float aspect = tracking->camera.pixel_aspect;
 
        if (stab->ok)
                return stab->scale;
 
        if (stabilization_median_point(tracking, 1, firstmedian)) {
-               int sfra= INT_MAX, efra= INT_MIN, cfra;
-               float scale= 1.0f;
+               int sfra = INT_MAX, efra = INT_MIN, cfra;
+               float scale = 1.0f;
                MovieTrackingTrack *track;
 
-               stab->scale= 1.0f;
+               stab->scale = 1.0f;
 
-               track= tracking->tracks.first;
+               track = tracking->tracks.first;
                while (track) {
-                       if (track->flag&TRACK_USE_2D_STAB ||
-                          ((stab->flag&TRACKING_STABILIZE_ROTATION) && track==stab->rot_track)) {
-                               sfra= MIN2(sfra, track->markers[0].framenr);
-                               efra= MAX2(efra, track->markers[track->markersnr-1].framenr);
+                       if (track->flag & TRACK_USE_2D_STAB ||
+                          ((stab->flag & TRACKING_STABILIZE_ROTATION) && track == stab->rot_track))
+                       {
+                               sfra = MIN2(sfra, track->markers[0].framenr);
+                               efra = MAX2(efra, track->markers[track->markersnr - 1].framenr);
                        }
 
-                       track= track->next;
+                       track = track->next;
                }
 
-               for (cfra=sfra; cfra<=efra; cfra++) {
+               for (cfra = sfra; cfra <= efra; cfra++) {
                        float median[2];
                        float loc[2], angle, tmp_scale;
                        int i;
                        float mat[4][4];
-                       float points[4][2]={{0.0f, 0.0f}, {0.0f, height}, {width, height}, {width, 0.0f}};
+                       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);
@@ -2573,9 +2633,9 @@ static float stabilization_auto_scale_factor(MovieTracking *tracking, int width,
                        si = sin(angle);
                        co = cos(angle);
 
-                       for (i= 0; i<4; i++) {
+                       for (i = 0; i < 4; i++) {
                                int j;
-                               float a[3]= {0.0f, 0.0f, 0.0f}, b[3]= {0.0f, 0.0f, 0.0f};
+                               float a[3] = {0.0f, 0.0f, 0.0f}, b[3]= {0.0f, 0.0f, 0.0f};
 
                                copy_v3_v3(a, points[i]);
                                copy_v3_v3(b, points[(i+1)%4]);
@@ -2583,8 +2643,8 @@ static float stabilization_auto_scale_factor(MovieTracking *tracking, int width,
                                mul_m4_v3(mat, a);
                                mul_m4_v3(mat, b);
 
-                               for (j= 0; j<4; j++) {
-                                       float point[3]= {points[j][0], points[j][1], 0.0f};
+                               for (j = 0; j < 4; j++) {
+                                       float point[3] = {points[j][0], points[j][1], 0.0f};
                                        float v1[3], v2[3];
 
                                        sub_v3_v3v3(v1, b, a);
@@ -2632,16 +2692,16 @@ static float stabilization_auto_scale_factor(MovieTracking *tracking, int width,
                        }
                }
 
-               stab->scale= scale;
+               stab->scale = scale;
 
                if (stab->maxscale>0.0f)
-                       stab->scale= MIN2(stab->scale, stab->maxscale);
+                       stab->scale = MIN2(stab->scale, stab->maxscale);
        }
        else {
-               stab->scale= 1.0f;
+               stab->scale = 1.0f;
        }
 
-       stab->ok= 1;
+       stab->ok = TRUE;
 
        return stab->scale;
 }
@@ -2652,23 +2712,24 @@ static ImBuf* stabilize_alloc_ibuf(ImBuf *cacheibuf, ImBuf *srcibuf, int fill)
 
        if (cacheibuf && (cacheibuf->x != srcibuf->x || cacheibuf->y != srcibuf->y)) {
                IMB_freeImBuf(cacheibuf);
-               cacheibuf= NULL;
+               cacheibuf = NULL;
        }
 
-       flags= IB_rect;
+       flags = IB_rect;
 
        if (srcibuf->rect_float)
-               flags|= IB_rectfloat;
+               flags |= IB_rectfloat;
 
        if (cacheibuf) {
                if (fill) {
-                       float col[4]= {0.0f, 0.0f, 0.0f, 0.0f};
+                       float col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
+
                        IMB_rectfill(cacheibuf, col);
                }
        }
        else {
-               cacheibuf= IMB_allocImBuf(srcibuf->x, srcibuf->y, srcibuf->planes, flags);
-               cacheibuf->profile= srcibuf->profile;
+               cacheibuf = IMB_allocImBuf(srcibuf->x, srcibuf->y, srcibuf->planes, flags);
+               cacheibuf->profile = srcibuf->profile;
        }
 
        return cacheibuf;
@@ -2677,9 +2738,9 @@ static ImBuf* stabilize_alloc_ibuf(ImBuf *cacheibuf, ImBuf *srcibuf, int fill)
 void BKE_tracking_stabilization_data(MovieTracking *tracking, int framenr, int width, int height, float loc[2], float *scale, float *angle)
 {
        float firstmedian[2], median[2];
-       MovieTrackingStabilization *stab= &tracking->stabilization;
+       MovieTrackingStabilization *stab = &tracking->stabilization;
 
-       if ((stab->flag&TRACKING_2D_STABILIZATION)==0) {
+       if ((stab->flag & TRACKING_2D_STABILIZATION) == 0) {
                zero_v2(loc);
                *scale= 1.0f;
                *angle= 0.0f;
@@ -2690,16 +2751,16 @@ void BKE_tracking_stabilization_data(MovieTracking *tracking, int framenr, int w
        if (stabilization_median_point(tracking, 1, firstmedian)) {
                stabilization_median_point(tracking, framenr, median);
 
-               if ((stab->flag&TRACKING_AUTOSCALE)==0)
-                       stab->scale= 1.0f;
+               if ((stab->flag & TRACKING_AUTOSCALE) == 0)
+                       stab->scale = 1.0f;
 
                if (!stab->ok) {
-                       if (stab->flag&TRACKING_AUTOSCALE)
+                       if (stab->flag & TRACKING_AUTOSCALE)
                                stabilization_auto_scale_factor(tracking, width, height);
 
                        calculate_stabdata(tracking, framenr, width, height, firstmedian, median, loc, scale, angle);
 
-                       stab->ok= 1;
+                       stab->ok = TRUE;
                }
                else {
                        calculate_stabdata(tracking, framenr, width, height, firstmedian, median, loc, scale, angle);
@@ -2707,56 +2768,65 @@ void BKE_tracking_stabilization_data(MovieTracking *tracking, int framenr, int w
        }
        else {
                zero_v2(loc);
-               *scale= 1.0f;
-               *angle= 0.0f;
+               *scale = 1.0f;
+               *angle = 0.0f;
        }
 }
 
 ImBuf *BKE_tracking_stabilize(MovieTracking *tracking, int framenr, ImBuf *ibuf, float loc[2], float *scale, float *angle)
 {
        float tloc[2], tscale, tangle;
-       MovieTrackingStabilization *stab= &tracking->stabilization;
+       MovieTrackingStabilization *stab = &tracking->stabilization;
        ImBuf *tmpibuf;
-       float width= ibuf->x, height= ibuf->y;
-       float aspect= tracking->camera.pixel_aspect;
+       float width = ibuf->x, height = ibuf->y;
+       float aspect = tracking->camera.pixel_aspect;
 
-       if (loc)                copy_v2_v2(tloc, loc);
-       if (scale)      tscale= *scale;
+       if (loc)
+               copy_v2_v2(tloc, loc);
 
-       if ((stab->flag&TRACKING_2D_STABILIZATION)==0) {
-               if (loc)                zero_v2(loc);
-               if (scale)      *scale= 1.0f;
+       if (scale)
+               tscale = *scale;
+
+       if ((stab->flag & TRACKING_2D_STABILIZATION) == 0) {
+               if (loc)
+                       zero_v2(loc);
+
+               if (scale)
+                       *scale = 1.0f;
 
                return ibuf;
        }
 
        BKE_tracking_stabilization_data(tracking, framenr, width, height, tloc, &tscale, &tangle);
 
-       tmpibuf= stabilize_alloc_ibuf(NULL, ibuf, 1);
+       tmpibuf = stabilize_alloc_ibuf(NULL, ibuf, TRUE);
 
        /* scale would be handled by matrix transformation when angle is non-zero */
-       if (tscale!=1.0f && tangle==0.0f) {
+       if (tscale != 1.0f && tangle == 0.0f) {
                ImBuf *scaleibuf;
 
                stabilization_auto_scale_factor(tracking, width, height);
 
-               scaleibuf= stabilize_alloc_ibuf(stab->scaleibuf, ibuf, 0);
-               stab->scaleibuf= scaleibuf;
+               scaleibuf = stabilize_alloc_ibuf(stab->scaleibuf, ibuf, 0);
+               stab->scaleibuf = scaleibuf;
 
                IMB_rectcpy(scaleibuf, ibuf, 0, 0, 0, 0, ibuf->x, ibuf->y);
                IMB_scalefastImBuf(scaleibuf, ibuf->x*tscale, ibuf->y*tscale);
 
-               ibuf= scaleibuf;
+               ibuf = scaleibuf;
        }
 
-       if (tangle==0.0f) {
+       if (tangle == 0.0f) {
                /* if angle is zero, then it's much faster to use rect copy
                 * but could be issues with subpixel precisions */
-               IMB_rectcpy(tmpibuf, ibuf, tloc[0]-(tscale-1.0f)*width/2.0f, tloc[1]-(tscale-1.0f)*height/2.0f, 0, 0, ibuf->x, ibuf->y);
+               IMB_rectcpy(tmpibuf, ibuf,
+                           tloc[0] - (tscale - 1.0f) * width / 2.0f,
+                           tloc[1] - (tscale - 1.0f) * height / 2.0f,
+                           0, 0, ibuf->x, ibuf->y);
        }
        else {
                float mat[4][4];
-               int i, j, filter= tracking->stabilization.filter;
+               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);
@@ -2772,9 +2842,9 @@ ImBuf *BKE_tracking_stabilize(MovieTracking *tracking, int framenr, ImBuf *ibuf,
                        /* fallback to default interpolation method */
                        interpolation = neareast_interpolation;
 
-               for (j=0; j<tmpibuf->y; j++) {
-                       for (i=0; i<tmpibuf->x;i++) {
-                               float vec[3]= {i, j, 0};
+               for (j = 0; j < tmpibuf->y; j++) {
+                       for (i = 0; i < tmpibuf->x;i++) {
+                               float vec[3] = {i, j, 0};
 
                                mul_v3_m4v3(vec, mat, vec);
 
@@ -2783,14 +2853,19 @@ ImBuf *BKE_tracking_stabilize(MovieTracking *tracking, int framenr, ImBuf *ibuf,
                }
        }
 
-       tmpibuf->userflags|= IB_MIPMAP_INVALID;
+       tmpibuf->userflags |= IB_MIPMAP_INVALID;
 
        if (tmpibuf->rect_float)
-               tmpibuf->userflags|= IB_RECT_INVALID;
+               tmpibuf->userflags |= IB_RECT_INVALID;
+
+       if (loc)
+               copy_v2_v2(loc, tloc);
 
-       if (loc)                copy_v2_v2(loc, tloc);
-       if (scale)      *scale= tscale;
-       if (angle)      *angle= tangle;
+       if (scale)
+               *scale= tscale;
+
+       if (angle)
+               *angle= tangle;
 
        return tmpibuf;
 }
@@ -2811,8 +2886,8 @@ void BKE_tracking_stabdata_to_mat4(int width, int height, float aspect, float lo
        invert_m4_m4(iamat, amat);
 
        /* image center as rotation center */
-       cmat[3][0]= (float)width/2.0f;
-       cmat[3][1]= (float)height/2.0f;
+       cmat[3][0] = (float)width / 2.0f;
+       cmat[3][1] = (float)height / 2.0f;
        invert_m4_m4(icmat, cmat);
 
        size_to_mat4(smat, svec);               /* scale matrix */
@@ -2827,7 +2902,7 @@ MovieDistortion *BKE_tracking_distortion_create(void)
 {
        MovieDistortion *distortion;
 
-       distortion= MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
+       distortion = MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
 
        return distortion;
 }
@@ -2836,12 +2911,12 @@ MovieDistortion *BKE_tracking_distortion_copy(MovieDistortion *distortion)
 {
        MovieDistortion *new_distortion;
 
-       new_distortion= MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
+       new_distortion = MEM_callocN(sizeof(MovieDistortion), "BKE_tracking_distortion_create");
 
 #ifdef WITH_LIBMV
-       new_distortion->intrinsics= libmv_CameraIntrinsicsCopy(distortion->intrinsics);
+       new_distortion->intrinsics = libmv_CameraIntrinsicsCopy(distortion->intrinsics);
 #else
-       (void)distortion;
+       (void) distortion;
 #endif
 
        return new_distortion;
@@ -2849,12 +2924,12 @@ MovieDistortion *BKE_tracking_distortion_copy(MovieDistortion *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;
+       MovieTrackingCamera *camera = &tracking->camera;
+       float aspy = 1.0f / tracking->camera.pixel_aspect;
 
 #ifdef WITH_LIBMV
        if (!distortion->intrinsics) {
-               distortion->intrinsics= libmv_CameraIntrinsicsNew(camera->focal,
+               distortion->intrinsics = libmv_CameraIntrinsicsNew(camera->focal,
                                camera->principal[0], camera->principal[1] * aspy,
                                camera->k1, camera->k2, camera->k3, width, height * aspy);
        }
@@ -2864,22 +2939,22 @@ void BKE_tracking_distortion_update(MovieDistortion *distortion, MovieTracking *
                                camera->k1, camera->k2, camera->k3, width, height * aspy);
        }
 #else
-       (void)distortion;
-       (void)width;
-       (void)height;
-       (void)camera;
-       (void)aspy;
+       (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 *ibuf, int width, int height, float overscan, int undistort)
 {
        ImBuf *resibuf;
 
        BKE_tracking_distortion_update(distortion, tracking, width, height);
 
-       resibuf= IMB_dupImBuf(ibuf);
+       resibuf = IMB_dupImBuf(ibuf);
 
        if (ibuf->rect_float) {
 #ifdef WITH_LIBMV
@@ -2895,7 +2970,7 @@ ImBuf *BKE_tracking_distortion_exec(MovieDistortion *distortion, MovieTracking *
                }
 #endif
 
-               ibuf->userflags|= IB_RECT_INVALID;
+               ibuf->userflags |= IB_RECT_INVALID;
        }
        else {
 #ifdef WITH_LIBMV
@@ -2913,8 +2988,8 @@ ImBuf *BKE_tracking_distortion_exec(MovieDistortion *distortion, MovieTracking *
        }
 
 #ifndef WITH_LIBMV
-       (void)overscan;
-       (void)undistort;
+       (void) overscan;
+       (void) undistort;
 #endif
 
        return resibuf;
@@ -2931,20 +3006,20 @@ void BKE_tracking_distortion_destroy(MovieDistortion *distortion)
 
 ImBuf *BKE_tracking_undistort(MovieTracking *tracking, ImBuf *ibuf, int width, int height, float overscan)
 {
-       MovieTrackingCamera *camera= &tracking->camera;
+       MovieTrackingCamera *camera = &tracking->camera;
 
        if (camera->intrinsics == NULL)
-               camera->intrinsics= BKE_tracking_distortion_create();
+               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;
+       MovieTrackingCamera *camera = &tracking->camera;
 
        if (camera->intrinsics == NULL)
-               camera->intrinsics= BKE_tracking_distortion_create();
+               camera->intrinsics = BKE_tracking_distortion_create();
 
        return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, width, height, overscan, 0);
 }
@@ -2956,11 +3031,11 @@ void BKE_tracking_select_track(ListBase *tracksbase, MovieTrackingTrack *track,
                BKE_tracking_track_flag(track, area, SELECT, 0);
        }
        else {
-               MovieTrackingTrack *cur= tracksbase->first;
+               MovieTrackingTrack *cur = tracksbase->first;
 
                while (cur) {
                        if ((cur->flag & TRACK_HIDDEN) == 0) {
-                               if (cur==track) {
+                               if (cur == track) {
                                        BKE_tracking_track_flag(cur, TRACK_AREA_ALL, SELECT, 1);
                                        BKE_tracking_track_flag(cur, area, SELECT, 0);
                                }
@@ -2969,7 +3044,7 @@ void BKE_tracking_select_track(ListBase *tracksbase, MovieTrackingTrack *track,
                                }
                        }
 
-                       cur= cur->next;
+                       cur = cur->next;
                }
        }
 }
@@ -2981,13 +3056,13 @@ void BKE_tracking_deselect_track(MovieTrackingTrack *track, int area)
 
 MovieTrackingObject *BKE_tracking_new_object(MovieTracking *tracking, const char *name)
 {
-       MovieTrackingObject *object= MEM_callocN(sizeof(MovieTrackingObject), "tracking object");
+       MovieTrackingObject *object = MEM_callocN(sizeof(MovieTrackingObject), "tracking object");
 
-       if (tracking->tot_object==0) {
+       if (tracking->tot_object == 0) {
                /* first object is always camera */
                BLI_strncpy(object->name, "Camera", sizeof(object->name));
 
-               object->flag|= TRACKING_OBJECT_CAMERA;
+               object->flag |= TRACKING_OBJECT_CAMERA;
        }
        else {
                BLI_strncpy(object->name, name, sizeof(object->name));
@@ -2996,9 +3071,9 @@ MovieTrackingObject *BKE_tracking_new_object(MovieTracking *tracking, const char
        BLI_addtail(&tracking->objects, object);
 
        tracking->tot_object++;
-       tracking->objectnr= BLI_countlist(&tracking->objects) - 1;
+       tracking->objectnr = BLI_countlist(&tracking->objects) - 1;
 
-       object->scale= 1.0f;
+       object->scale = 1.0f;
 
        BKE_tracking_object_unique_name(tracking, object);
 
@@ -3008,7 +3083,7 @@ MovieTrackingObject *BKE_tracking_new_object(MovieTracking *tracking, const char
 void BKE_tracking_remove_object(MovieTracking *tracking, MovieTrackingObject *object)
 {
        MovieTrackingTrack *track;
-       int index= BLI_findindex(&tracking->objects, object);
+       int index = BLI_findindex(&tracking->objects, object);
 
        if (index<0)
                return;
@@ -3018,10 +3093,10 @@ void BKE_tracking_remove_object(MovieTracking *tracking, MovieTrackingObject *ob
                return;
        }
 
-       track= object->tracks.first;
+       track = object->tracks.first;
        while (track) {
-               if (track==tracking->act_track)
-                       tracking->act_track= NULL;
+               if (track == tracking->act_track)
+                       tracking->act_track = NULL;
 
                track= track->next;
        }
@@ -3032,9 +3107,9 @@ void BKE_tracking_remove_object(MovieTracking *tracking, MovieTrackingObject *ob
        tracking->tot_object--;
 
        if (index>0)
-               tracking->objectnr= index-1;
+               tracking->objectnr = index - 1;
        else
-               tracking->objectnr= 0;
+               tracking->objectnr = 0;
 }
 
 void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *object)
@@ -3044,13 +3119,13 @@ void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObjec
 
 MovieTrackingObject *BKE_tracking_named_object(MovieTracking *tracking, const char *name)
 {
-       MovieTrackingObject *object= tracking->objects.first;
+       MovieTrackingObject *object = tracking->objects.first;
 
        while (object) {
                if (!strcmp(object->name, name))
                        return object;
 
-               object= object->next;
+               object = object->next;
        }
 
        return NULL;
index bb816d1b8b2487958eaeae86d0bfc8a2a9101d05..eabd64bdc4f29573633fdb8508a7bf22c086f5f0 100644 (file)
@@ -67,11 +67,11 @@ void ED_clip_buttons_register(ARegionType *art)
 {
        PanelType *pt;
 
-       pt= MEM_callocN(sizeof(PanelType), "spacetype clip panel gpencil");
+       pt = MEM_callocN(sizeof(PanelType), "spacetype clip panel gpencil");
        strcpy(pt->idname, "CLIP_PT_gpencil");
        strcpy(pt->label, "Grease Pencil");
-       pt->draw= gpencil_panel_standard;
-       pt->flag|= PNL_DEFAULT_CLOSED;
+       pt->draw = gpencil_panel_standard;
+       pt->flag |= PNL_DEFAULT_CLOSED;
        BLI_addtail(&art->paneltypes, pt);
 }
 
@@ -88,7 +88,7 @@ void uiTemplateMovieClip(uiLayout *layout, bContext *C, PointerRNA *ptr, const c
        if (!ptr->data)
                return;
 
-       prop= RNA_struct_find_property(ptr, propname);
+       prop = RNA_struct_find_property(ptr, propname);
        if (!prop) {
                printf("%s: property not found: %s.%s\n",
                       __func__, RNA_struct_identifier(ptr->type), propname);
@@ -101,8 +101,8 @@ void uiTemplateMovieClip(uiLayout *layout, bContext *C, PointerRNA *ptr, const c
                return;
        }
 
-       clipptr= RNA_property_pointer_get(ptr, prop);
-       clip= clipptr.data;
+       clipptr = RNA_property_pointer_get(ptr, prop);
+       clip = clipptr.data;
 
        uiLayoutSetContextPointer(layout, "edit_movieclip", &clipptr);
 
@@ -110,13 +110,13 @@ void uiTemplateMovieClip(uiLayout *layout, bContext *C, PointerRNA *ptr, const c
                uiTemplateID(layout, C, ptr, propname, NULL, "CLIP_OT_open", NULL);
 
        if (clip) {
-               row= uiLayoutRow(layout, 0);
-               block= uiLayoutGetBlock(row);
+               row = uiLayoutRow(layout, 0);
+               block = uiLayoutGetBlock(row);
                uiDefBut(block, LABEL, 0, "File Path:", 0, 19, 145, 19, NULL, 0, 0, 0, 0, "");
 
-               row= uiLayoutRow(layout, 0);
+               row = uiLayoutRow(layout, 0);
                split = uiLayoutSplit(row, 0.0, 0);
-               row= uiLayoutRow(split, 1);
+               row = uiLayoutRow(split, 1);
 
                uiItemR(row, &clipptr, "filepath", 0, "", ICON_NONE);
                uiItemO(row, "", ICON_FILE_REFRESH, "clip.reload");
@@ -136,7 +136,7 @@ void uiTemplateTrack(uiLayout *layout, PointerRNA *ptr, const char *propname)
        if (!ptr->data)
                return;
 
-       prop= RNA_struct_find_property(ptr, propname);
+       prop = RNA_struct_find_property(ptr, propname);
        if (!prop) {
                printf("%s: property not found: %s.%s\n",
                       __func__, RNA_struct_identifier(ptr->type), propname);
@@ -149,15 +149,15 @@ void uiTemplateTrack(uiLayout *layout, PointerRNA *ptr, const char *propname)
                return;
        }
 
-       scopesptr= RNA_property_pointer_get(ptr, prop);
-       scopes= (MovieClipScopes *)scopesptr.data;
+       scopesptr = RNA_property_pointer_get(ptr, prop);
+       scopes = (MovieClipScopes *)scopesptr.data;
 
        rect.xmin = 0; rect.xmax = 200;
        rect.ymin = 0; rect.ymax = 120;
 
-       block= uiLayoutAbsoluteBlock(layout);
+       block = uiLayoutAbsoluteBlock(layout);
 
-       scopes->track_preview_height= (scopes->track_preview_height<=UI_UNIT_Y)?UI_UNIT_Y:scopes->track_preview_height;
+       scopes->track_preview_height = (scopes->track_preview_height<=UI_UNIT_Y)?UI_UNIT_Y:scopes->track_preview_height;
 
        uiDefBut(block, TRACKPREVIEW, 0, "", rect.xmin, rect.ymin, rect.xmax-rect.xmin, scopes->track_preview_height, scopes, 0, 0, 0, 0, "");
 }
@@ -189,89 +189,89 @@ typedef struct {
 static void to_pixel_space(float r[2], float a[2], int width, int height)
 {
        copy_v2_v2(r, a);
-       r[0]*= width;
-       r[1]*= height;
+       r[0] *= width;
+       r[1] *= height;
 }
 
 static void marker_update_cb(bContext *C, void *arg_cb, void *UNUSED(arg))
 {
-       MarkerUpdateCb *cb= (MarkerUpdateCb*) arg_cb;
+       MarkerUpdateCb *cb = (MarkerUpdateCb*) arg_cb;
        MovieTrackingMarker *marker;
 
        if (!cb->compact)
                return;
 
-       marker= BKE_tracking_ensure_marker(cb->track, cb->framenr);
+       marker = BKE_tracking_ensure_marker(cb->track, cb->framenr);
 
-       marker->flag= cb->marker_flag;
+       marker->flag = cb->marker_flag;
 
        WM_event_add_notifier(C, NC_MOVIECLIP|NA_EDITED, NULL);
 }
 
 static void marker_block_handler(bContext *C, void *arg_cb, int event)
 {
-       MarkerUpdateCb *cb= (MarkerUpdateCb*) arg_cb;
+       MarkerUpdateCb *cb = (MarkerUpdateCb*) arg_cb;
        MovieTrackingMarker *marker;
-       int width, height, ok= 0;
+       int width, height, ok = FALSE;
 
        BKE_movieclip_get_size(cb->clip, cb->user, &width, &height);
 
-       marker= BKE_tracking_ensure_marker(cb->track, cb->framenr);
+       marker = BKE_tracking_ensure_marker(cb->track, cb->framenr);
 
-       if (event==B_MARKER_POS) {
-               marker->pos[0]= cb->marker_pos[0]/width;
-               marker->pos[1]= cb->marker_pos[1]/height;
+       if (event == B_MARKER_POS) {
+               marker->pos[0] = cb->marker_pos[0]/width;
+               marker->pos[1] = cb->marker_pos[1]/height;
 
                /* to update position of "parented" objects */
                DAG_id_tag_update(&cb->clip->id, 0);
                WM_event_add_notifier(C, NC_SPACE|ND_SPACE_VIEW3D, NULL);
 
-               ok= 1;
+               ok = TRUE;
        }
-       else if (event==B_MARKER_PAT_DIM) {
+       else if (event == B_MARKER_PAT_DIM) {
                float dim[2], pat_dim[2];
 
                sub_v2_v2v2(pat_dim, cb->track->pat_max, cb->track->pat_min);
 
-               dim[0]= cb->track_pat[0]/width;
-               dim[1]= cb->track_pat[1]/height;
+               dim[0] = cb->track_pat[0] / width;
+               dim[1] = cb->track_pat[1] / height;
 
                sub_v2_v2(dim, pat_dim);
                mul_v2_fl(dim, 0.5f);
 
-               cb->track->pat_min[0]-= dim[0];
-               cb->track->pat_min[1]-= dim[1];
+               cb->track->pat_min[0] -= dim[0];
+               cb->track->pat_min[1] -= dim[1];
 
-               cb->track->pat_max[0]+= dim[0];
-               cb->track->pat_max[1]+= dim[1];
+               cb->track->pat_max[0] += dim[0];
+               cb->track->pat_max[1] += dim[1];
 
                BKE_tracking_clamp_track(cb->track, CLAMP_PAT_DIM);
 
-               ok= 1;
+               ok = TRUE;
        }
-       else if (event==B_MARKER_SEARCH_POS) {
+       else if (event == B_MARKER_SEARCH_POS) {
                float delta[2], side[2];
 
                sub_v2_v2v2(side, cb->track->search_max, cb->track->search_min);
                mul_v2_fl(side, 0.5f);
 
-               delta[0]= cb->track_search_pos[0]/width;
-               delta[1]= cb->track_search_pos[1]/height;
+               delta[0] = cb->track_search_pos[0] / width;
+               delta[1] = cb->track_search_pos[1] / height;
 
                sub_v2_v2v2(cb->track->search_min, delta, side);
                add_v2_v2v2(cb->track->search_max, delta, side);
 
                BKE_tracking_clamp_track(cb->track, CLAMP_SEARCH_POS);
 
-               ok= 1;
+               ok = TRUE;
        }
-       else if (event==B_MARKER_SEARCH_DIM) {
+       else if (event == B_MARKER_SEARCH_DIM) {
                float dim[2], search_dim[2];
 
                sub_v2_v2v2(search_dim, cb->track->search_max, cb->track->search_min);
 
-               dim[0]= cb->track_search[0]/width;
-               dim[1]= cb->track_search[1]/height;
+               dim[0] = cb->track_search[0]/width;
+               dim[1] = cb->track_search[1]/height;
 
                sub_v2_v2(dim, search_dim);
                mul_v2_fl(dim, 0.5f);
@@ -284,31 +284,31 @@ static void marker_block_handler(bContext *C, void *arg_cb, int event)
 
                BKE_tracking_clamp_track(cb->track, CLAMP_SEARCH_DIM);
 
-               ok= 1;
+               ok = TRUE;
        }
-       else if (event==B_MARKER_FLAG) {
-               marker->flag= cb->marker_flag;
+       else if (event == B_MARKER_FLAG) {
+               marker->flag = cb->marker_flag;
 
-               ok= 1;
+               ok = TRUE;
        }
-       else if (event==B_MARKER_OFFSET) {
+       else if (event == B_MARKER_OFFSET) {
                float offset[2], delta[2];
                int i;
 
-               offset[0]= cb->track_offset[0]/width;
-               offset[1]= cb->track_offset[1]/height;
+               offset[0] = cb->track_offset[0] / width;
+               offset[1] = cb->track_offset[1] / height;
 
                sub_v2_v2v2(delta, offset, cb->track->offset);
                copy_v2_v2(cb->track->offset, offset);
 
-               for (i=0; i<cb->track->markersnr; i++)
+               for (i = 0; i < cb->track->markersnr; i++)
                        sub_v2_v2(cb->track->markers[i].pos, delta);
 
                /* to update position of "parented" objects */
                DAG_id_tag_update(&cb->clip->id, 0);
                WM_event_add_notifier(C, NC_SPACE|ND_SPACE_VIEW3D, NULL);
 
-               ok= 1;
+               ok = TRUE;
        }
 
        if (ok)
@@ -331,7 +331,7 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
        if (!ptr->data)
                return;
 
-       prop= RNA_struct_find_property(ptr, propname);
+       prop = RNA_struct_find_property(ptr, propname);
        if (!prop) {
                printf("%s: property not found: %s.%s\n",
                       __func__, RNA_struct_identifier(ptr->type), propname);
@@ -344,30 +344,30 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
                return;
        }
 
-       clipptr= RNA_property_pointer_get(ptr, prop);
-       clip= (MovieClip *)clipptr.data;
-       user= userptr->data;
-       track= trackptr->data;
+       clipptr = RNA_property_pointer_get(ptr, prop);
+       clip = (MovieClip *)clipptr.data;
+       user = userptr->data;
+       track = trackptr->data;
 
-       marker= BKE_tracking_get_marker(track, user->framenr);
+       marker = BKE_tracking_get_marker(track, user->framenr);
 
-       cb= MEM_callocN(sizeof(MarkerUpdateCb), "uiTemplateMarker update_cb");
-       cb->compact= compact;
-       cb->clip= clip;
-       cb->user= user;
-       cb->track= track;
-       cb->marker_flag= marker->flag;
-       cb->framenr= user->framenr;
+       cb = MEM_callocN(sizeof(MarkerUpdateCb), "uiTemplateMarker update_cb");
+       cb->compact = compact;
+       cb->clip = clip;
+       cb->user = user;
+       cb->track = track;
+       cb->marker_flag = marker->flag;
+       cb->framenr = user->framenr;
 
        if (compact) {
-               block= uiLayoutGetBlock(layout);
+               block = uiLayoutGetBlock(layout);
 
-               if (cb->marker_flag&MARKER_DISABLED)
+               if (cb->marker_flag & MARKER_DISABLED)
                        tip= "Marker is disabled at current frame";
                else
                        tip= "Marker is enabled at current frame";
 
-               bt= uiDefIconButBitI(block, TOGN, MARKER_DISABLED, 0, ICON_RESTRICT_VIEW_OFF, 0, 0, 20, 20, &cb->marker_flag, 0, 0, 1, 0, tip);
+               bt = uiDefIconButBitI(block, TOGN, MARKER_DISABLED, 0, ICON_RESTRICT_VIEW_OFF, 0, 0, 20, 20, &cb->marker_flag, 0, 0, 1, 0, tip);
                uiButSetNFunc(bt, marker_update_cb, cb, NULL);
        }
        else {
@@ -377,16 +377,16 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
 
                BKE_movieclip_get_size(clip, user, &width, &height);
 
-               if (track->flag&TRACK_LOCKED) {
+               if (track->flag & TRACK_LOCKED) {
                        uiLayoutSetActive(layout, 0);
-                       block= uiLayoutAbsoluteBlock(layout);
+                       block = uiLayoutAbsoluteBlock(layout);
                        uiDefBut(block, LABEL, 0, "Track is locked", 0, 0, 300, 19, NULL, 0, 0, 0, 0, "");
 
                        return;
                }
 
                step= 100;
-               digits= 2;
+               digits = 2;
 
                sub_v2_v2v2(pat_dim, track->pat_max, track->pat_min);
                sub_v2_v2v2(search_dim, track->search_max, track->search_min);
@@ -403,13 +403,13 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
                to_pixel_space(cb->track_search_pos, search_pos, width, height);
                to_pixel_space(cb->track_offset, track->offset, width, height);
 
-               cb->marker_flag= marker->flag;
+               cb->marker_flag = marker->flag;
 
                block= uiLayoutAbsoluteBlock(layout);
                uiBlockSetHandleFunc(block, marker_block_handler, cb);
                uiBlockSetNFunc(block, marker_update_cb, cb, NULL);
 
-               if (cb->marker_flag&MARKER_DISABLED)
+               if (cb->marker_flag & MARKER_DISABLED)
                        tip= "Marker is disabled at current frame";
                else
                        tip= "Marker is enabled at current frame";
@@ -417,10 +417,10 @@ void uiTemplateMarker(uiLayout *layout, PointerRNA *ptr, const char *propname, P
                uiDefButBitI(block, OPTIONN, MARKER_DISABLED, B_MARKER_FLAG,  "Enabled", 10, 190, 145, 19, &cb->marker_flag,
                        0, 0, 0, 0, tip);
 
-               col= uiLayoutColumn(layout, 1);
+               col = uiLayoutColumn(layout, 1);
                uiLayoutSetActive(col, (cb->marker_flag&MARKER_DISABLED)==0);
 
-               block= uiLayoutAbsoluteBlock(col);
+               block = uiLayoutAbsoluteBlock(col);
                uiBlockBeginAlign(block);
 
                uiDefBut(block, LABEL, 0, "Position:", 0, 190, 300, 19, NULL, 0, 0, 0, 0, "");
index ef83a62c2908dc583fcd58c9bfdf490a742da56a..019b23c231bf0933500b2a7fa6dc6de6e9e5babe 100644 (file)
@@ -73,8 +73,8 @@
 
 void clip_draw_curfra_label(SpaceClip *sc, float x, float y)
 {
-       uiStyle *style= UI_GetStyle();
-       int fontid= style->widget.uifont_id;
+       uiStyle *style = UI_GetStyle();
+       int fontid = style->widget.uifont_id;
        char numstr[32];
        float font_dims[2] = {0.0f, 0.0f};
 
@@ -95,9 +95,9 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
 {
        float x;
        int *points, totseg, i, a;
-       float sfra= SFRA, efra= EFRA, framelen= ar->winx/(efra-sfra+1);
-       MovieTrackingTrack *act_track= BKE_tracking_active_track(&clip->tracking);
-       MovieTrackingReconstruction *reconstruction= BKE_tracking_get_reconstruction(&clip->tracking);
+       float sfra = SFRA, efra = EFRA, framelen = ar->winx / (efra - sfra + 1);
+       MovieTrackingTrack *act_track = BKE_tracking_active_track(&clip->tracking);
+       MovieTrackingReconstruction *reconstruction = BKE_tracking_get_reconstruction(&clip->tracking);
 
        glEnable(GL_BLEND);
 
@@ -110,11 +110,11 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
        if (totseg) {
                glColor4ub(128, 128, 255, 128);
 
-               for (a= 0; a<totseg; a++) {
+               for (a = 0; a < totseg; a++) {
                        float x1, x2;
 
-                       x1= (points[a*2]-sfra)/(efra-sfra+1)*ar->winx;
-                       x2= (points[a*2+1]-sfra+1)/(efra-sfra+1)*ar->winx;
+                       x1 = (points[a * 2] - sfra) / (efra - sfra + 1) * ar->winx;
+                       x2 = (points[a * 2 + 1] - sfra + 1) / (efra - sfra + 1) * ar->winx;
 
                        glRecti(x1, 0, x2, 8);
                }
@@ -122,53 +122,58 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
 
        /* track */
        if (act_track) {
-               MovieTrackingTrack *track= act_track;
+               MovieTrackingTrack *track = act_track;
 
-               for (i= sfra, a= 0; i <= efra; i++) {
+               for (i = sfra, a = 0; i <= efra; i++) {
                        int framenr;
                        MovieTrackingMarker *marker;
 
                        while (a<track->markersnr) {
-                               if (track->markers[a].framenr>=i)
+                               if (track->markers[a].framenr >= i)
                                        break;
 
-                               if (a<track->markersnr-1 && track->markers[a+1].framenr>i)
+                               if (a < track->markersnr - 1 && track->markers[a + 1].framenr > i)
                                        break;
 
                                a++;
                        }
 
-                       if (a<track->markersnr) marker= &track->markers[a];
-                       else marker= &track->markers[track->markersnr-1];
+                       if (a < track->markersnr)
+                               marker = &track->markers[a];
+                       else
+                               marker = &track->markers[track->markersnr - 1];
 
-                       if ((marker->flag&MARKER_DISABLED)==0) {
-                               framenr= marker->framenr;
+                       if ((marker->flag & MARKER_DISABLED) == 0) {
+                               framenr = marker->framenr;
 
-                               if (framenr!=i) glColor4ub(128, 128, 0, 96);
-                               else if ((marker->flag&MARKER_TRACKED)==0) glColor4ub(255, 255, 0, 196);
-                               else glColor4ub(255, 255, 0, 96);
+                               if (framenr != i)
+                                       glColor4ub(128, 128, 0, 96);
+                               else if ((marker->flag & MARKER_TRACKED) == 0)
+                                       glColor4ub(255, 255, 0, 196);
+                               else
+                                       glColor4ub(255, 255, 0, 96);
 
-                               glRecti((i-sfra)*framelen, 0, (i-sfra+1)*framelen, 4);
+                               glRecti((i - sfra) * framelen, 0, (i - sfra + 1)*framelen, 4);
                        }
                }
        }
 
        /* failed frames */
-       if (reconstruction->flag&TRACKING_RECONSTRUCTED) {
-               int n= reconstruction->camnr;
-               MovieReconstructedCamera *cameras= reconstruction->cameras;
+       if (reconstruction->flag & TRACKING_RECONSTRUCTED) {
+               int n = reconstruction->camnr;
+               MovieReconstructedCamera *cameras = reconstruction->cameras;
 
                glColor4ub(255, 0, 0, 96);
 
-               for (i= sfra, a= 0; i <= efra; i++) {
-                       int ok= 0;
+               for (i = sfra, a = 0; i <= efra; i++) {
+                       int ok = FALSE;
 
-                       while (a<n) {
-                               if (cameras[a].framenr==i) {
-                                       ok= 1;
+                       while (a < n) {
+                               if (cameras[a].framenr == i) {
+                                       ok = TRUE;
                                        break;
                                }
-                               else if (cameras[a].framenr>i) {
+                               else if (cameras[a].framenr > i) {
                                        break;
                                }
 
@@ -176,14 +181,14 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
                        }
 
                        if (!ok)
-                               glRecti((i-sfra)*framelen, 0, (i-sfra+1)*framelen, 8);
+                               glRecti((i - sfra) * framelen, 0, (i - sfra + 1) * framelen, 8);
                }
        }
 
        glDisable(GL_BLEND);
 
        /* current frame */
-       x= (sc->user.framenr-sfra)/(efra-sfra+1)*ar->winx;
+       x = (sc->user.framenr - sfra) / (efra - sfra + 1) * ar->winx;
 
        UI_ThemeColor(TH_CFRAME);
        glRecti(x, 0, x+framelen, 8);
@@ -193,17 +198,17 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
 
 static void draw_movieclip_notes(SpaceClip *sc, ARegion *ar)
 {
-       MovieClip *clip= ED_space_clip(sc);
-       MovieTracking *tracking= &clip->tracking;
-       char str[256]= {0};
-       int block= 0;
+       MovieClip *clip = ED_space_clip(sc);
+       MovieTracking *tracking = &clip->tracking;
+       char str[256] = {0};
+       int block = FALSE;
 
        if (tracking->stats) {
                BLI_strncpy(str, tracking->stats->message, sizeof(str));
-               block= 1;
+               block = TRUE;
        }
        else {
-               if (sc->flag&SC_LOCK_SELECTION)
+               if (sc->flag & SC_LOCK_SELECTION)
                        strcpy(str, "Locked");
        }
 
@@ -212,10 +217,10 @@ static void draw_movieclip_notes(SpaceClip *sc, ARegion *ar)
 }
 
 static void draw_movieclip_buffer(SpaceClip *sc, ARegion *ar, ImBuf *ibuf,
-                       int width, int height, float zoomx, float zoomy)
+                                  int width, int height, float zoomx, float zoomy)
 {
        int x, y;
-       MovieClip *clip= ED_space_clip(sc);
+       MovieClip *clip = ED_space_clip(sc);
 
        /* set zoom */
        glPixelZoom(zoomx*width/ibuf->x, zoomy*height/ibuf->y);
@@ -223,9 +228,9 @@ static void draw_movieclip_buffer(SpaceClip *sc, ARegion *ar, ImBuf *ibuf,
        /* find window pixel coordinates of origin */
        UI_view2d_to_region_no_clip(&ar->v2d, 0.0f, 0.0f, &x, &y);
 
-       if (sc->flag&SC_MUTE_FOOTAGE) {
+       if (sc->flag & SC_MUTE_FOOTAGE) {
                glColor3f(0.0f, 0.0f, 0.0f);
-               glRectf(x, y, x+zoomx*width, y+zoomy*height);
+               glRectf(x, y, x + zoomx * width, y + zoomy * height);
        }
        else {
                if (ibuf->rect_float && !ibuf->rect) {
@@ -237,7 +242,7 @@ static void draw_movieclip_buffer(SpaceClip *sc, ARegion *ar, ImBuf *ibuf,
        }
 
        /* draw boundary border for frame if stabilization is enabled */
-       if (sc->flag&SC_SHOW_STABLE && clip->tracking.stabilization.flag&TRACKING_2D_STABILIZATION) {
+       if (sc->flag & SC_SHOW_STABLE && clip->tracking.stabilization.flag & TRACKING_2D_STABILIZATION) {
                glColor3f(0.0f, 0.0f, 0.0f);
                glLineStipple(3, 0xaaaa);
                glEnable(GL_LINE_STIPPLE);
@@ -270,35 +275,35 @@ static void draw_movieclip_buffer(SpaceClip *sc, ARegion *ar, ImBuf *ibuf,
 
 static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackingTrack *track)
 {
-       int count= sc->path_length;
-       int i, a, b, curindex= -1;
+       int count = sc->path_length;
+       int i, a, b, curindex = -1;
        float path[102][2];
-       int tiny= sc->flag&SC_SHOW_TINY_MARKER, framenr;
+       int tiny = sc->flag&SC_SHOW_TINY_MARKER, framenr;
        MovieTrackingMarker *marker;
 
-       if (count==0)
+       if (count == 0)
                return;
 
-       marker= BKE_tracking_get_marker(track, sc->user.framenr);
-       if (marker->framenr!=sc->user.framenr || marker->flag&MARKER_DISABLED)
+       marker = BKE_tracking_get_marker(track, sc->user.framenr);
+       if (marker->framenr != sc->user.framenr || marker->flag & MARKER_DISABLED)
                return;
 
-       framenr= marker->framenr;
+       framenr = marker->framenr;
 
-       a= count;
-       i= framenr-1;
-       while (i>=framenr-count) {
-               marker= BKE_tracking_get_marker(track, i);
+       a = count;
+       i = framenr - 1;
+       while (i >= framenr - count) {
+               marker = BKE_tracking_get_marker(track, i);
 
-               if (!marker || marker->flag&MARKER_DISABLED)
+               if (!marker || marker->flag & MARKER_DISABLED)
                        break;
 
-               if (marker->framenr==i) {
+               if (marker->framenr == i) {
                        add_v2_v2v2(path[--a], marker->pos, track->offset);
                        ED_clip_point_undistorted_pos(sc, path[a], path[a]);
 
-                       if (marker->framenr==sc->user.framenr)
-                               curindex= a;
+                       if (marker->framenr == sc->user.framenr)
+                               curindex = a;
                }
                else {
                        break;
@@ -307,16 +312,16 @@ static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackin
                i--;
        }
 
-       b= count;
-       i= framenr;
-       while (i<=framenr+count) {
-               marker= BKE_tracking_get_marker(track, i);
+       b = count;
+       i = framenr;
+       while (i <= framenr+count) {
+               marker = BKE_tracking_get_marker(track, i);
 
-               if (!marker || marker->flag&MARKER_DISABLED)
+               if (!marker || marker->flag & MARKER_DISABLED)
                        break;
 
-               if (marker->framenr==i) {
-                       if (marker->framenr==sc->user.framenr)
+               if (marker->framenr == i) {
+                       if (marker->framenr == sc->user.framenr)
                                curindex= b;
 
                        add_v2_v2v2(path[b++], marker->pos, track->offset);
@@ -334,8 +339,8 @@ static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackin
                if (TRACK_VIEW_SELECTED(sc, track)) {
                        glPointSize(5.0f);
                        glBegin(GL_POINTS);
-                               for (i= a; i<b; i++) {
-                                       if (i!=curindex)
+                               for (i = a; i < b; i++) {
+                                       if (i != curindex)
                                                glVertex2f(path[i][0], path[i][1]);
                                }
                        glEnd();
@@ -343,7 +348,7 @@ static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackin
 
                glLineWidth(3.0f);
                glBegin(GL_LINE_STRIP);
-                       for (i= a; i<b; i++)
+                       for (i = a; i < b; i++)
                                glVertex2f(path[i][0], path[i][1]);
                glEnd();
                glLineWidth(1.0f);
@@ -354,11 +359,11 @@ static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackin
        if (TRACK_VIEW_SELECTED(sc, track)) {
                glPointSize(3.0f);
                glBegin(GL_POINTS);
-                       for (i= a; i<b; i++) {
-                               if (i==count+1)
+                       for (i = a; i < b; i++) {
+                               if (i == count + 1)
                                        UI_ThemeColor(TH_PATH_AFTER);
 
-                               if (i!=curindex)
+                               if (i != curindex)
                                        glVertex2f(path[i][0], path[i][1]);
                        }
                glEnd();
@@ -367,8 +372,8 @@ static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackin
        UI_ThemeColor(TH_PATH_BEFORE);
 
        glBegin(GL_LINE_STRIP);
-               for (i= a; i<b; i++) {
-                       if (i==count+1)
+               for (i = a; i < b; i++) {
+                       if (i == count + 1)
                                UI_ThemeColor(TH_PATH_AFTER);
 
                        glVertex2f(path[i][0], path[i][1]);
@@ -379,16 +384,16 @@ static void draw_track_path(SpaceClip *sc, MovieClip *UNUSED(clip), MovieTrackin
 
 static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker, float marker_pos[2], int width, int height)
 {
-       int tiny= sc->flag&SC_SHOW_TINY_MARKER;
-       int show_search= 0;
+       int tiny = sc->flag&SC_SHOW_TINY_MARKER;
+       int show_search = FALSE;
        float px[2];
 
        UI_ThemeColor(TH_MARKER_OUTLINE);
 
-       px[0]= 1.0f/width/sc->zoom;
-       px[1]= 1.0f/height/sc->zoom;
+       px[0] = 1.0f / width / sc->zoom;
+       px[1] = 1.0f / height / sc->zoom;
 
-       if ((marker->flag&MARKER_DISABLED)==0) {
+       if ((marker->flag & MARKER_DISABLED) == 0) {
                float pos[2];
                rctf r;
 
@@ -428,9 +433,10 @@ static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieT
        glPushMatrix();
        glTranslatef(marker_pos[0], marker_pos[1], 0);
 
-       if (!tiny) glLineWidth(3.0f);
+       if (!tiny)
+               glLineWidth(3.0f);
 
-       if (sc->flag&SC_SHOW_MARKER_PATTERN) {
+       if (sc->flag & SC_SHOW_MARKER_PATTERN) {
                glBegin(GL_LINE_LOOP);
                        glVertex2f(track->pat_min[0], track->pat_min[1]);
                        glVertex2f(track->pat_max[0], track->pat_min[1]);
@@ -439,8 +445,9 @@ static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieT
                glEnd();
        }
 
-       show_search= TRACK_VIEW_SELECTED(sc, track) && ((marker->flag&MARKER_DISABLED)==0 || (sc->flag&SC_SHOW_MARKER_PATTERN)==0);
-       if (sc->flag&SC_SHOW_MARKER_SEARCH && show_search) {
+       show_search = TRACK_VIEW_SELECTED(sc, track) &&
+                     ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0);
+       if (sc->flag & SC_SHOW_MARKER_SEARCH && show_search) {
                glBegin(GL_LINE_LOOP);
                        glVertex2f(track->search_min[0], track->search_min[1]);
                        glVertex2f(track->search_max[0], track->search_min[1]);
@@ -450,22 +457,27 @@ static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieT
        }
        glPopMatrix();
 
-       if (!tiny) glLineWidth(1.0f);
+       if (!tiny)
+               glLineWidth(1.0f);
 }
 
 static void track_colors(MovieTrackingTrack *track, int act, float col[3], float scol[3])
 {
-       if (track->flag&TRACK_CUSTOMCOLOR) {
-               if (act) UI_GetThemeColor3fv(TH_ACT_MARKER, scol);
-               else copy_v3_v3(scol, track->color);
+       if (track->flag & TRACK_CUSTOMCOLOR) {
+               if (act)
+                       UI_GetThemeColor3fv(TH_ACT_MARKER, scol);
+               else
+                       copy_v3_v3(scol, track->color);
 
                mul_v3_v3fl(col, track->color, 0.5f);
        }
        else {
                UI_GetThemeColor3fv(TH_MARKER, col);
 
-               if (act) UI_GetThemeColor3fv(TH_ACT_MARKER, scol);
-               else UI_GetThemeColor3fv(TH_SEL_MARKER, scol);
+               if (act)
+                       UI_GetThemeColor3fv(TH_ACT_MARKER, scol);
+               else
+                       UI_GetThemeColor3fv(TH_SEL_MARKER, scol);
        }
 }
 
@@ -477,22 +489,27 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 
        track_colors(track, act, col, scol);
 
-       px[0]= 1.0f/width/sc->zoom;
-       px[1]= 1.0f/height/sc->zoom;
+       px[0]= 1.0f / width / sc->zoom;
+       px[1]= 1.0f / height / sc->zoom;
 
        /* marker position and offset position */
-       if ((track->flag&SELECT)==sel && (marker->flag&MARKER_DISABLED)==0) {
+       if ((track->flag&SELECT) == sel && (marker->flag & MARKER_DISABLED) == 0) {
                float pos[2];
                rctf r;
 
-               if (track->flag&TRACK_LOCKED) {
-                       if (act) UI_ThemeColor(TH_ACT_MARKER);
-                       else if (track->flag&SELECT) UI_ThemeColorShade(TH_LOCK_MARKER, 64);
-                       else UI_ThemeColor(TH_LOCK_MARKER);
+               if (track->flag & TRACK_LOCKED) {
+                       if (act)
+                               UI_ThemeColor(TH_ACT_MARKER);
+                       else if (track->flag & SELECT)
+                               UI_ThemeColorShade(TH_LOCK_MARKER, 64);
+                       else
+                               UI_ThemeColor(TH_LOCK_MARKER);
                }
                else {
-                       if (track->flag&SELECT) glColor3fv(scol);
-                       else glColor3fv(col);
+                       if (track->flag & SELECT)
+                               glColor3fv(scol);
+                       else
+                               glColor3fv(col);
                }
 
                BLI_init_rctf(&r, track->pat_min[0], track->pat_max[0], track->pat_min[1], track->pat_max[1]);
@@ -500,11 +517,15 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
                ED_clip_point_undistorted_pos(sc, pos, pos);
 
                if (BLI_in_rctf(&r, pos[0]-marker_pos[0], pos[1]-marker_pos[1])) {
-                       if (!tiny) glPointSize(2.0f);
+                       if (!tiny)
+                               glPointSize(2.0f);
+
                        glBegin(GL_POINTS);
                                glVertex2f(pos[0], pos[1]);
                        glEnd();
-                       if (!tiny) glPointSize(1.0f);
+
+                       if (!tiny)
+                               glPointSize(1.0f);
                }
                else {
                        glBegin(GL_LINES);
@@ -546,19 +567,24 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
                glEnable(GL_LINE_STIPPLE);
        }
 
-       if ((track->pat_flag&SELECT)==sel && (sc->flag&SC_SHOW_MARKER_PATTERN)) {
-               if (track->flag&TRACK_LOCKED) {
-                       if (act) UI_ThemeColor(TH_ACT_MARKER);
-                       else if (track->pat_flag&SELECT) UI_ThemeColorShade(TH_LOCK_MARKER, 64);
+       if ((track->pat_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_PATTERN)) {
+               if (track->flag & TRACK_LOCKED) {
+                       if (act)
+                               UI_ThemeColor(TH_ACT_MARKER);
+                       else if (track->pat_flag & SELECT)
+                               UI_ThemeColorShade(TH_LOCK_MARKER, 64);
                        else UI_ThemeColor(TH_LOCK_MARKER);
                }
-               else if (marker->flag&MARKER_DISABLED) {
-                       if (act) UI_ThemeColor(TH_ACT_MARKER);
-                       else if (track->pat_flag&SELECT) UI_ThemeColorShade(TH_DIS_MARKER, 128);
+               else if (marker->flag & MARKER_DISABLED) {
+                       if (act)
+                               UI_ThemeColor(TH_ACT_MARKER);
+                       else if (track->pat_flag & SELECT)
+                               UI_ThemeColorShade(TH_DIS_MARKER, 128);
                        else UI_ThemeColor(TH_DIS_MARKER);
                }
                else {
-                       if (track->pat_flag&SELECT) glColor3fv(scol);
+                       if (track->pat_flag & SELECT)
+                               glColor3fv(scol);
                        else glColor3fv(col);
                }
 
@@ -571,21 +597,28 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
        }
 
        /* search */
-       show_search= TRACK_VIEW_SELECTED(sc, track) && ((marker->flag&MARKER_DISABLED)==0 || (sc->flag&SC_SHOW_MARKER_PATTERN)==0);
-       if ((track->search_flag&SELECT)==sel && (sc->flag&SC_SHOW_MARKER_SEARCH) && show_search) {
-               if (track->flag&TRACK_LOCKED) {
-                       if (act) UI_ThemeColor(TH_ACT_MARKER);
-                       else if (track->search_flag&SELECT) UI_ThemeColorShade(TH_LOCK_MARKER, 64);
+       show_search = TRACK_VIEW_SELECTED(sc, track) &&
+                    ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0);
+       if ((track->search_flag & SELECT) == sel && (sc->flag & SC_SHOW_MARKER_SEARCH) && show_search) {
+               if (track->flag & TRACK_LOCKED) {
+                       if (act)
+                               UI_ThemeColor(TH_ACT_MARKER);
+                       else if (track->search_flag & SELECT)
+                               UI_ThemeColorShade(TH_LOCK_MARKER, 64);
                        else UI_ThemeColor(TH_LOCK_MARKER);
                }
-               else if (marker->flag&MARKER_DISABLED) {
-                       if (act) UI_ThemeColor(TH_ACT_MARKER);
-                       else if (track->search_flag&SELECT) UI_ThemeColorShade(TH_DIS_MARKER, 128);
+               else if (marker->flag & MARKER_DISABLED) {
+                       if (act)
+                               UI_ThemeColor(TH_ACT_MARKER);
+                       else if (track->search_flag & SELECT)
+                               UI_ThemeColorShade(TH_DIS_MARKER, 128);
                        else UI_ThemeColor(TH_DIS_MARKER);
                }
                else {
-                       if (track->search_flag&SELECT) glColor3fv(scol);
-                       else glColor3fv(col);
+                       if (track->search_flag & SELECT)
+                               glColor3fv(scol);
+                       else
+                               glColor3fv(col);
                }
 
                glBegin(GL_LINE_LOOP);
@@ -597,20 +630,29 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
        }
 
        /* pyramid */
-       if (sel && TRACK_VIEW_SELECTED(sc, track) && (track->tracker==TRACKER_KLT) && (marker->flag&MARKER_DISABLED)==0) {
-               if (track->flag&TRACK_LOCKED) {
-                       if (act) UI_ThemeColor(TH_ACT_MARKER);
-                       else if (track->pat_flag&SELECT) UI_ThemeColorShade(TH_LOCK_MARKER, 64);
+       if (sel && TRACK_VIEW_SELECTED(sc, track) &&
+           (track->tracker == TRACKER_KLT) &&
+               (marker->flag & MARKER_DISABLED) == 0)
+       {
+               if (track->flag & TRACK_LOCKED) {
+                       if (act)
+                               UI_ThemeColor(TH_ACT_MARKER);
+                       else if (track->pat_flag & SELECT)
+                               UI_ThemeColorShade(TH_LOCK_MARKER, 64);
                        else UI_ThemeColor(TH_LOCK_MARKER);
                }
-               else if (marker->flag&MARKER_DISABLED) {
-                       if (act) UI_ThemeColor(TH_ACT_MARKER);
-                       else if (track->pat_flag&SELECT) UI_ThemeColorShade(TH_DIS_MARKER, 128);
+               else if (marker->flag & MARKER_DISABLED) {
+                       if (act)
+                               UI_ThemeColor(TH_ACT_MARKER);
+                       else if (track->pat_flag & SELECT)
+                               UI_ThemeColorShade(TH_DIS_MARKER, 128);
                        else UI_ThemeColor(TH_DIS_MARKER);
                }
                else {
-                       if (track->pat_flag&SELECT) glColor3fv(scol);
-                       else glColor3fv(col);
+                       if (track->pat_flag & SELECT)
+                               glColor3fv(scol);
+                       else
+                               glColor3fv(col);
                }
 
                {
@@ -639,16 +681,16 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 }
 
 static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                       float marker_pos[2], int outline, int sel, int act, int width, int height)
+                                    float marker_pos[2], int outline, int sel, int act, int width, int height)
 {
        float x, y, dx, dy, patdx, patdy, searchdx, searchdy, tdx, tdy;
-       int tiny= sc->flag&SC_SHOW_TINY_MARKER;
+       int tiny = sc->flag&SC_SHOW_TINY_MARKER;
        float col[3], scol[3], px[2];
 
-       if ((tiny && outline) || (marker->flag&MARKER_DISABLED))
+       if ((tiny && outline) || (marker->flag & MARKER_DISABLED))
                return;
 
-       if (!TRACK_VIEW_SELECTED(sc, track) || track->flag&TRACK_LOCKED)
+       if (!TRACK_VIEW_SELECTED(sc, track) || track->flag & TRACK_LOCKED)
                return;
 
        track_colors(track, act, col, scol);
@@ -661,34 +703,36 @@ static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, Mo
        glPushMatrix();
        glTranslatef(marker_pos[0], marker_pos[1], 0);
 
-       dx= 6.0f/width/sc->zoom;
-       dy= 6.0f/height/sc->zoom;
+       dx = 6.0f / width / sc->zoom;
+       dy = 6.0f / height / sc->zoom;
 
-       patdx= MIN2(dx*2.0f/3.0f, (track->pat_max[0]-track->pat_min[0])/6.0f);
-       patdy= MIN2(dy*2.0f/3.0f, (track->pat_max[1]-track->pat_min[1])/6.0f);
+       patdx = MIN2(dx * 2.0f / 3.0f, (track->pat_max[0] - track->pat_min[0]) / 6.0f);
+       patdy = MIN2(dy * 2.0f / 3.0f, (track->pat_max[1] - track->pat_min[1]) / 6.0f);
 
-       searchdx= MIN2(dx, (track->search_max[0]-track->search_min[0])/6.0f);
-       searchdy= MIN2(dy, (track->search_max[1]-track->search_min[1])/6.0f);
+       searchdx = MIN2(dx, (track->search_max[0] - track->search_min[0]) / 6.0f);
+       searchdy = MIN2(dy, (track->search_max[1] - track->search_min[1]) / 6.0f);
 
-       px[0]= 1.0f/sc->zoom/width/sc->scale;
-       px[1]= 1.0f/sc->zoom/height/sc->scale;
+       px[0] = 1.0f / sc->zoom / width / sc->scale;
+       px[1] = 1.0f / sc->zoom / height / sc->scale;
 
-       if ((sc->flag&SC_SHOW_MARKER_SEARCH) && ((track->search_flag&SELECT)==sel || outline)) {
+       if ((sc->flag & SC_SHOW_MARKER_SEARCH) && ((track->search_flag & SELECT) == sel || outline)) {
                if (!outline) {
-                       if (track->search_flag&SELECT) glColor3fv(scol);
-                       else glColor3fv(col);
+                       if (track->search_flag & SELECT)
+                               glColor3fv(scol);
+                       else
+                               glColor3fv(col);
                }
 
                /* search offset square */
-               x= track->search_min[0];
-               y= track->search_max[1];
+               x = track->search_min[0];
+               y = track->search_max[1];
 
-               tdx= searchdx;
-               tdy= searchdy;
+               tdx = searchdx;
+               tdy = searchdy;
 
                if (outline) {
-                       tdx+= px[0];
-                       tdy+= px[1];
+                       tdx += px[0];
+                       tdy += px[1];
                }
 
                glBegin(GL_QUADS);
@@ -699,15 +743,15 @@ static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, Mo
                glEnd();
 
                /* search re-sizing triangle */
-               x= track->search_max[0];
-               y= track->search_min[1];
+               x = track->search_max[0];
+               y = track->search_min[1];
 
-               tdx= searchdx*2.0f;
-               tdy= searchdy*2.0f;
+               tdx = searchdx*2.0f;
+               tdy = searchdy*2.0f;
 
                if (outline) {
-                       tdx+= px[0];
-                       tdy+= px[1];
+                       tdx += px[0];
+                       tdy += px[1];
                }
 
                glBegin(GL_TRIANGLES);
@@ -717,22 +761,24 @@ static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, Mo
                glEnd();
        }
 
-       if ((sc->flag&SC_SHOW_MARKER_PATTERN) && ((track->pat_flag&SELECT)==sel || outline)) {
+       if ((sc->flag & SC_SHOW_MARKER_PATTERN) && ((track->pat_flag & SELECT)==sel || outline)) {
                if (!outline) {
-                       if (track->pat_flag&SELECT) glColor3fv(scol);
-                       else glColor3fv(col);
+                       if (track->pat_flag & SELECT)
+                               glColor3fv(scol);
+                       else
+                               glColor3fv(col);
                }
 
                /* pattern offset square */
-               x= track->pat_min[0];
-               y= track->pat_max[1];
+               x = track->pat_min[0];
+               y = track->pat_max[1];
 
-               tdx= patdx;
-               tdy= patdy;
+               tdx = patdx;
+               tdy = patdy;
 
                if (outline) {
-                       tdx+= px[0];
-                       tdy+= px[1];
+                       tdx += px[0];
+                       tdy += px[1];
                }
 
                glBegin(GL_QUADS);
@@ -743,15 +789,15 @@ static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, Mo
                glEnd();
 
                /* pattern re-sizing triangle */
-               x= track->pat_max[0];
-               y= track->pat_min[1];
+               x = track->pat_max[0];
+               y = track->pat_min[1];
 
-               tdx= patdx*2.0f;
-               tdy= patdy*2.0f;
+               tdx = patdx*2.0f;
+               tdy = patdy*2.0f;
 
                if (outline) {
-                       tdx+= px[0];
-                       tdy+= px[1];
+                       tdx += px[0];
+                       tdy += px[1];
                }
 
                glBegin(GL_TRIANGLES);
@@ -768,52 +814,60 @@ static void draw_marker_slide_zones(SpaceClip *sc, MovieTrackingTrack *track, Mo
 }
 
 static void draw_marker_texts(SpaceClip *sc, MovieTrackingTrack *track, MovieTrackingMarker *marker, float marker_pos[2], int act,
-                       int width, int height, float zoomx, float zoomy)
+                              int width, int height, float zoomx, float zoomy)
 {
-       char str[128]= {0}, state[64]= {0};
-       float dx= 0.0f, dy= 0.0f, fontsize, pos[3];
-       uiStyle *style= U.uistyles.first;
-       int fontid= style->widget.uifont_id;
+       char str[128] = {0}, state[64] = {0};
+       float dx= 0.0f, dy = 0.0f, fontsize, pos[3];
+       uiStyle *style = U.uistyles.first;
+       int fontid = style->widget.uifont_id;
 
        if (!TRACK_VIEW_SELECTED(sc, track))
                return;
 
        BLF_size(fontid, 11.0f, U.dpi);
-       fontsize= BLF_height_max(fontid);
+       fontsize = BLF_height_max(fontid);
 
-       if (marker->flag&MARKER_DISABLED) {
-               if (act) UI_ThemeColor(TH_ACT_MARKER);
-               else UI_ThemeColorShade(TH_DIS_MARKER, 128);
+       if (marker->flag & MARKER_DISABLED) {
+               if (act)
+                       UI_ThemeColor(TH_ACT_MARKER);
+               else
+                       UI_ThemeColorShade(TH_DIS_MARKER, 128);
        }
        else {
-               if (act) UI_ThemeColor(TH_ACT_MARKER);
-               else UI_ThemeColor(TH_SEL_MARKER);
+               if (act)
+                       UI_ThemeColor(TH_ACT_MARKER);
+               else
+                       UI_ThemeColor(TH_SEL_MARKER);
        }
 
-       if ((sc->flag&SC_SHOW_MARKER_SEARCH) &&
-          ((marker->flag&MARKER_DISABLED)==0 || (sc->flag&SC_SHOW_MARKER_PATTERN)==0))
+       if ((sc->flag & SC_SHOW_MARKER_SEARCH) &&
+          ((marker->flag & MARKER_DISABLED) == 0 || (sc->flag & SC_SHOW_MARKER_PATTERN) == 0))
        {
-               dx= track->search_min[0];
-               dy= track->search_min[1];
+               dx = track->search_min[0];
+               dy = track->search_min[1];
        }
-       else if (sc->flag&SC_SHOW_MARKER_PATTERN) {
-               dx= track->pat_min[0];
-               dy= track->pat_min[1];
+       else if (sc->flag & SC_SHOW_MARKER_PATTERN) {
+               dx = track->pat_min[0];
+               dy = track->pat_min[1];
        }
 
-       pos[0]= (marker_pos[0]+dx)*width;
-       pos[1]= (marker_pos[1]+dy)*height;
-       pos[2]= 0.0f;
+       pos[0] = (marker_pos[0] + dx) * width;
+       pos[1] = (marker_pos[1] + dy) * height;
+       pos[2] = 0.0f;
 
        mul_m4_v3(sc->stabmat, pos);
 
-       pos[0]= pos[0]*zoomx;
-       pos[1]= pos[1]*zoomy - fontsize;
+       pos[0] = pos[0]*zoomx;
+       pos[1] = pos[1]*zoomy - fontsize;
 
-       if (marker->flag&MARKER_DISABLED) strcpy(state, "disabled");
-       else if (marker->framenr!=sc->user.framenr) strcpy(state, "estimated");
-       else if (marker->flag&MARKER_TRACKED) strcpy(state, "tracked");
-       else strcpy(state, "keyframed");
+       if (marker->flag & MARKER_DISABLED)
+               strcpy(state, "disabled");
+       else if (marker->framenr != sc->user.framenr)
+               strcpy(state, "estimated");
+       else if (marker->flag & MARKER_TRACKED)
+               strcpy(state, "tracked");
+       else
+               strcpy(state, "keyframed");
 
        if (state[0])
                BLI_snprintf(str, sizeof(str), "%s: %s", track->name, state);
@@ -822,16 +876,16 @@ static void draw_marker_texts(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 
        BLF_position(fontid, pos[0], pos[1], 0.0f);
        BLF_draw(fontid, str, sizeof(str));
-       pos[1]-= fontsize;
+       pos[1] -= fontsize;
 
-       if (track->flag&TRACK_HAS_BUNDLE) {
+       if (track->flag & TRACK_HAS_BUNDLE) {
                BLI_snprintf(str, sizeof(str), "Average error: %.3f", track->error);
                BLF_position(fontid, pos[0], pos[1], 0.0f);
                BLF_draw(fontid, str, sizeof(str));
-               pos[1]-= fontsize;
+               pos[1] -= fontsize;
        }
 
-       if (track->flag&TRACK_LOCKED) {
+       if (track->flag & TRACK_LOCKED) {
                BLF_position(fontid, pos[0], pos[1], 0.0f);
                BLF_draw(fontid, "locked", 6);
        }
@@ -840,25 +894,25 @@ static void draw_marker_texts(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 static void view2d_to_region_float(View2D *v2d, float x, float y, float *regionx, float *regiony)
 {
        /* express given coordinates as proportional values */
-       x= -v2d->cur.xmin / (v2d->cur.xmax-v2d->cur.xmin);
-       y= -v2d->cur.ymin / (v2d->cur.ymax-v2d->cur.ymin);
+       x = -v2d->cur.xmin / (v2d->cur.xmax - v2d->cur.xmin);
+       y = -v2d->cur.ymin / (v2d->cur.ymax - v2d->cur.ymin);
 
        /* convert proportional distances to screen coordinates */
-       *regionx= v2d->mask.xmin + x*(v2d->mask.xmax-v2d->mask.xmin);
-       *regiony= v2d->mask.ymin + y*(v2d->mask.ymax-v2d->mask.ymin);
+       *regionx = v2d->mask.xmin + x*(v2d->mask.xmax - v2d->mask.xmin);
+       *regiony = v2d->mask.ymin + y*(v2d->mask.ymax - v2d->mask.ymin);
 }
 
 static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
-                       int width, int height, float zoomx, float zoomy)
+                                 int width, int height, float zoomx, float zoomy)
 {
        float x, y;
-       MovieTracking* tracking= &clip->tracking;
-       ListBase *tracksbase= BKE_tracking_get_tracks(tracking);
+       MovieTracking *tracking = &clip->tracking;
+       ListBase *tracksbase = BKE_tracking_get_tracks(tracking);
        MovieTrackingTrack *track, *act_track;
        MovieTrackingMarker *marker;
-       int framenr= sc->user.framenr;
-       int undistort= sc->user.render_flag&MCLIP_PROXY_RENDER_UNDISTORT;
-       float *marker_pos= NULL, *fp, *active_pos= NULL, cur_pos[2];
+       int framenr = sc->user.framenr;
+       int undistort = sc->user.render_flag & MCLIP_PROXY_RENDER_UNDISTORT;
+       float *marker_pos = NULL, *fp, *active_pos = NULL, cur_pos[2];
 
        /* ** find window pixel coordinates of origin ** */
 
@@ -877,65 +931,65 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
        glMultMatrixf(sc->stabmat);
        glScalef(width, height, 0);
 
-       act_track= BKE_tracking_active_track(tracking);
+       act_track = BKE_tracking_active_track(tracking);
 
-       if (sc->user.render_flag&MCLIP_PROXY_RENDER_UNDISTORT) {
-               int count= 0;
+       if (sc->user.render_flag & MCLIP_PROXY_RENDER_UNDISTORT) {
+               int count = 0;
 
                /* count */
-               track= tracksbase->first;
+               track = tracksbase->first;
                while (track) {
-                       if ((track->flag&TRACK_HIDDEN)==0) {
-                               marker= BKE_tracking_get_marker(track, framenr);
+                       if ((track->flag & TRACK_HIDDEN)==0) {
+                               marker = BKE_tracking_get_marker(track, framenr);
 
                                if (MARKER_VISIBLE(sc, marker))
                                        count++;
                        }
 
-                       track= track->next;
+                       track = track->next;
                }
 
                /* undistort */
                if (count) {
-                       marker_pos= MEM_callocN(2*sizeof(float)*count, "draw_tracking_tracks marker_pos");
+                       marker_pos = MEM_callocN(2*sizeof(float)*count, "draw_tracking_tracks marker_pos");
 
-                       track= tracksbase->first;
-                       fp= marker_pos;
+                       track = tracksbase->first;
+                       fp = marker_pos;
                        while (track) {
-                               if ((track->flag&TRACK_HIDDEN)==0) {
-                                       marker= BKE_tracking_get_marker(track, framenr);
+                               if ((track->flag & TRACK_HIDDEN)==0) {
+                                       marker = BKE_tracking_get_marker(track, framenr);
 
                                        if (MARKER_VISIBLE(sc, marker)) {
                                                ED_clip_point_undistorted_pos(sc, marker->pos, fp);
 
-                                               if (track==act_track)
-                                                       active_pos= fp;
+                                               if (track == act_track)
+                                                       active_pos = fp;
 
-                                               fp+= 2;
+                                               fp += 2;
                                        }
                                }
 
-                               track= track->next;
+                               track = track->next;
                        }
                }
        }
 
-       if (sc->flag&SC_SHOW_TRACK_PATH) {
-               track= tracksbase->first;
+       if (sc->flag & SC_SHOW_TRACK_PATH) {
+               track = tracksbase->first;
                while (track) {
-                       if ((track->flag&TRACK_HIDDEN)==0)
+                       if ((track->flag & TRACK_HIDDEN)==0)
                                draw_track_path(sc, clip, track);
 
-                       track= track->next;
+                       track = track->next;
                }
        }
 
        /* markers outline and non-selected areas */
-       track= tracksbase->first;
-       fp= marker_pos;
+       track = tracksbase->first;
+       fp = marker_pos;
        while (track) {
-               if ((track->flag&TRACK_HIDDEN)==0) {
-                       marker= BKE_tracking_get_marker(track, framenr);
+               if ((track->flag & TRACK_HIDDEN)==0) {
+                       marker = BKE_tracking_get_marker(track, framenr);
 
                        if (MARKER_VISIBLE(sc, marker)) {
                                copy_v2_v2(cur_pos, fp ? fp : marker->pos);
@@ -946,21 +1000,21 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
                                draw_marker_slide_zones(sc, track, marker, cur_pos, 0, 0, 0, width, height);
 
                                if (fp)
-                                       fp+= 2;
+                                       fp += 2;
                        }
                }
 
-               track= track->next;
+               track = track->next;
        }
 
        /* selected areas only, so selection wouldn't be overlapped by
         * non-selected areas */
-       track= tracksbase->first;
-       fp= marker_pos;
+       track = tracksbase->first;
+       fp = marker_pos;
        while (track) {
-               if ((track->flag&TRACK_HIDDEN)==0) {
-                       int act= track==act_track;
-                       marker= BKE_tracking_get_marker(track, framenr);
+               if ((track->flag & TRACK_HIDDEN)==0) {
+                       int act = track == act_track;
+                       marker = BKE_tracking_get_marker(track, framenr);
 
                        if (MARKER_VISIBLE(sc, marker)) {
                                if (!act) {
@@ -971,17 +1025,17 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
                                }
 
                                if (fp)
-                                       fp+= 2;
+                                       fp += 2;
                        }
                }
 
-               track= track->next;
+               track = track->next;
        }
 
        /* active marker would be displayed on top of everything else */
        if (act_track) {
-               if ((act_track->flag&TRACK_HIDDEN)==0) {
-                       marker= BKE_tracking_get_marker(act_track, framenr);
+               if ((act_track->flag & TRACK_HIDDEN)==0) {
+                       marker = BKE_tracking_get_marker(act_track, framenr);
 
                        if (MARKER_VISIBLE(sc, marker)) {
                                copy_v2_v2(cur_pos, active_pos ? active_pos : marker->pos);
@@ -992,19 +1046,19 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
                }
        }
 
-       if (sc->flag&SC_SHOW_BUNDLES) {
-               MovieTrackingObject *object= BKE_tracking_active_object(tracking);
+       if (sc->flag & SC_SHOW_BUNDLES) {
+               MovieTrackingObject *object = BKE_tracking_active_object(tracking);
                float pos[4], vec[4], mat[4][4], aspy;
 
                glEnable(GL_POINT_SMOOTH);
                glPointSize(3.0f);
 
-               aspy= 1.0f/clip->tracking.camera.pixel_aspect;
+               aspy = 1.0f / clip->tracking.camera.pixel_aspect;
                BKE_tracking_projection_matrix(tracking, object, framenr, width, height, mat);
 
-               track= tracksbase->first;
+               track = tracksbase->first;
                while (track) {
-                       if ((track->flag&TRACK_HIDDEN)==0 && track->flag&TRACK_HAS_BUNDLE) {
+                       if ((track->flag & TRACK_HIDDEN) == 0 && track->flag & TRACK_HAS_BUNDLE) {
                                marker= BKE_tracking_get_marker(track, framenr);
 
                                if (MARKER_VISIBLE(sc, marker)) {
@@ -1014,29 +1068,33 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
 
                                        mul_v4_m4v4(pos, mat, vec);
 
-                                       pos[0]= (pos[0]/(pos[3]*2.0f)+0.5f)*width;
-                                       pos[1]= (pos[1]/(pos[3]*2.0f)+0.5f)*height*aspy;
+                                       pos[0] = (pos[0] / (pos[3] * 2.0f) + 0.5f) * width;
+                                       pos[1] = (pos[1] / (pos[3] * 2.0f) + 0.5f) * height * aspy;
 
                                        BKE_tracking_apply_intrinsics(tracking, pos, npos);
 
-                                       if (npos[0]>=0.0f && npos[1]>=0.0f && npos[0]<=width && npos[1]<=height*aspy) {
-                                               vec[0]= (marker->pos[0]+track->offset[0])*width;
-                                               vec[1]= (marker->pos[1]+track->offset[1])*height*aspy;
+                                       if (npos[0] >= 0.0f && npos[1] >= 0.0f && npos[0] <= width && npos[1] <= height * aspy) {
+                                               vec[0] = (marker->pos[0] + track->offset[0]) * width;
+                                               vec[1] = (marker->pos[1] + track->offset[1]) * height * aspy;
 
                                                sub_v2_v2(vec, npos);
 
-                                               if (len_v2(vec)<3) glColor3f(0.0f, 1.0f, 0.0f);
-                                               else glColor3f(1.0f, 0.0f, 0.0f);
+                                               if (len_v2(vec)< 3.0f)
+                                                       glColor3f(0.0f, 1.0f, 0.0f);
+                                               else
+                                                       glColor3f(1.0f, 0.0f, 0.0f);
 
                                                glBegin(GL_POINTS);
-                                                       if (undistort) glVertex3f(pos[0]/width, pos[1]/(height*aspy), 0);
-                                                       else glVertex3f(npos[0]/width, npos[1]/(height*aspy), 0);
+                                                       if (undistort)
+                                                               glVertex3f(pos[0] / width, pos[1] / (height * aspy), 0);
+                                                       else
+                                                               glVertex3f(npos[0] / width, npos[1] / (height * aspy), 0);
                                                glEnd();
                                        }
                                }
                        }
 
-                       track= track->next;
+                       track = track->next;
                }
 
                glPointSize(1.0f);
@@ -1045,26 +1103,27 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip,
 
        glPopMatrix();
 
-       if (sc->flag&SC_SHOW_NAMES) {
+       if (sc->flag & SC_SHOW_NAMES) {
                /* scaling should be cleared before drawing texts, otherwise font would also be scaled */
-               track= tracksbase->first;
-               fp= marker_pos;
+               track = tracksbase->first;
+               fp = marker_pos;
                while (track) {
-                       if ((track->flag&TRACK_HIDDEN)==0) {
-                               marker= BKE_tracking_get_marker(track, framenr);
+                       if ((track->flag & TRACK_HIDDEN) == 0) {
+                               marker = BKE_tracking_get_marker(track, framenr);
 
                                if (MARKER_VISIBLE(sc, marker)) {
-                                       int act= track==act_track;
+                                       int act = track == act_track;
 
                                        copy_v2_v2(cur_pos, fp ? fp : marker->pos);
 
                                        draw_marker_texts(sc, track, marker, cur_pos, act, width, height, zoomx, zoomy);
 
-                                       if (fp) fp+= 2;
+                                       if (fp)
+                                               fp += 2;
                                }
                        }