Cleanup: Variable naming in tracking files

Make it obvious that the object is the motion tracking one, and
not the ID_OB type.

source/blender/blenkernel/BKE_tracking.h

@@ -95,7 +95,7 @@ void BKE_tracking_get_camera_object_matrix(struct Object *camera_object, float m
  * \note frame number should be in clip space, not scene space.
  */
 void BKE_tracking_get_projection_matrix(struct MovieTracking *tracking,
-                                        struct MovieTrackingObject *object,
+                                        struct MovieTrackingObject *tracking_object,
                                         int framenr,
                                         int winx,
                                         int winy,
@@ -113,7 +113,7 @@ void BKE_tracking_clipboard_free(void);
  * Copy selected tracks from specified object to the clipboard.
  */
 void BKE_tracking_clipboard_copy_tracks(struct MovieTracking *tracking,
-                                        struct MovieTrackingObject *object);
+                                        struct MovieTrackingObject *tracking_object);
 /**
  * Check whether there are any tracks in the clipboard.
  */
@@ -124,7 +124,7 @@ bool BKE_tracking_clipboard_has_tracks(void);
  * Names of new tracks in object are guaranteed to be unique here.
  */
 void BKE_tracking_clipboard_paste_tracks(struct MovieTracking *tracking,
-                                         struct MovieTrackingObject *object);
+                                         struct MovieTrackingObject *tracking_object);
 
 /* **** Track **** */
 
@@ -248,9 +248,8 @@ void BKE_tracking_tracks_average(struct MovieTrackingTrack *dst_track,
                                  /*const*/ struct MovieTrackingTrack **src_tracks,
                                  int num_src_tracks);
 
-struct MovieTrackingTrack *BKE_tracking_track_get_named(struct MovieTracking *tracking,
+struct MovieTrackingTrack *BKE_tracking_track_get_named(
-                                                        struct MovieTrackingObject *object,
+    struct MovieTracking *tracking, struct MovieTrackingObject *tracking_object, const char *name);
-                                                        const char *name);
 struct MovieTrackingTrack *BKE_tracking_track_get_indexed(struct MovieTracking *tracking,
                                                           int tracknr,
                                                           struct ListBase **r_tracksbase);
@@ -382,7 +381,7 @@ bool BKE_tracking_plane_track_has_enabled_marker_at_frame(
     struct MovieTrackingPlaneTrack *plane_track, int framenr);
 
 struct MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_named(
-    struct MovieTracking *tracking, struct MovieTrackingObject *object, const char *name);
+    struct MovieTracking *tracking, struct MovieTrackingObject *tracking_object, const char *name);
 
 struct MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_active(
     struct MovieTracking *tracking);
@@ -440,10 +439,10 @@ void BKE_tracking_plane_marker_get_subframe_corners(struct MovieTrackingPlaneTra
 struct MovieTrackingObject *BKE_tracking_object_add(struct MovieTracking *tracking,
                                                     const char *name);
 bool BKE_tracking_object_delete(struct MovieTracking *tracking,
-                                struct MovieTrackingObject *object);
+                                struct MovieTrackingObject *tracking_object);
 
 void BKE_tracking_object_unique_name(struct MovieTracking *tracking,
-                                     struct MovieTrackingObject *object);
+                                     struct MovieTrackingObject *tracking_object);
 
 struct MovieTrackingObject *BKE_tracking_object_get_named(struct MovieTracking *tracking,
                                                           const char *name);
@@ -467,9 +466,9 @@ void BKE_tracking_camera_to_blender(struct MovieTracking *tracking,
                                     int height);
 
 struct MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(
-    struct MovieTracking *tracking, struct MovieTrackingObject *object, int framenr);
+    struct MovieTracking *tracking, struct MovieTrackingObject *tracking_object, int framenr);
 void BKE_tracking_camera_get_reconstructed_interpolate(struct MovieTracking *tracking,
-                                                       struct MovieTrackingObject *object,
+                                                       struct MovieTrackingObject *tracking_object,
                                                        float framenr,
                                                        float mat[4][4]);
 
@@ -619,7 +618,7 @@ void BKE_tracking_homography_between_two_quads(/*const*/ float reference_corners
  * Perform early check on whether everything is fine to start reconstruction.
  */
 bool BKE_tracking_reconstruction_check(struct MovieTracking *tracking,
-                                       struct MovieTrackingObject *object,
+                                       struct MovieTrackingObject *tracking_object,
                                        char *error_msg,
                                        int error_size);
 
@@ -630,7 +629,7 @@ bool BKE_tracking_reconstruction_check(struct MovieTracking *tracking,
  */
 struct MovieReconstructContext *BKE_tracking_reconstruction_context_new(
     struct MovieClip *clip,
-    struct MovieTrackingObject *object,
+    struct MovieTrackingObject *tracking_object,
     int keyframe1,
     int keyframe2,
     int width,

source/blender/blenkernel/intern/constraint.c

@@ -5232,11 +5232,11 @@ static void camerasolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
   if (clip) {
     float mat[4][4], obmat[4][4];
     MovieTracking *tracking = &clip->tracking;
-    MovieTrackingObject *object = BKE_tracking_object_get_camera(tracking);
+    MovieTrackingObject *tracking_object = BKE_tracking_object_get_camera(tracking);
-    float ctime = DEG_get_ctime(depsgraph);
+    const float ctime = DEG_get_ctime(depsgraph);
-    float framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime);
+    const float framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime);
 
-    BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
+    BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, mat);
 
     copy_m4_m4(obmat, cob->matrix);
 
@@ -5294,10 +5294,8 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
   }
 
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object;
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, data->object);
-
+  if (!tracking_object) {
-  object = BKE_tracking_object_get_named(tracking, data->object);
-  if (!object) {
     return;
   }
 
@@ -5305,7 +5303,7 @@ static void objectsolver_evaluate(bConstraint *con, bConstraintOb *cob, ListBase
   float ctime = DEG_get_ctime(depsgraph);
   float framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, ctime);
 
-  BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
+  BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, mat);
 
   invert_m4_m4(imat, mat);
   mul_m4_m4m4(parmat, camob->object_to_world, imat);

source/blender/blenkernel/intern/tracking.c

@@ -101,11 +101,11 @@ static void tracking_reconstruction_free(MovieTrackingReconstruction *reconstruc
  *
  * All the pointers inside structure becomes invalid after this call.
  */
-static void tracking_object_free(MovieTrackingObject *object)
+static void tracking_object_free(MovieTrackingObject *tracking_object)
 {
-  tracking_tracks_free(&object->tracks);
+  tracking_tracks_free(&tracking_object->tracks);
-  tracking_plane_tracks_free(&object->plane_tracks);
+  tracking_plane_tracks_free(&tracking_object->plane_tracks);
-  tracking_reconstruction_free(&object->reconstruction);
+  tracking_reconstruction_free(&tracking_object->reconstruction);
 }
 
 /* Free list of tracking objects, list's head and tail is set to NULL. */
@@ -252,43 +252,45 @@ static void tracking_stabilization_copy(MovieTrackingStabilization *stabilizatio
 }
 
 /* Copy tracking object. */
-static void tracking_object_copy(MovieTrackingObject *object_dst,
+static void tracking_object_copy(MovieTrackingObject *tracking_object_dst,
-                                 const MovieTrackingObject *object_src,
+                                 const MovieTrackingObject *tracking_object_src,
                                  const int flag)
 {
   TrackingCopyContext ctx = tracking_copy_context_new();
 
-  *object_dst = *object_src;
+  *tracking_object_dst = *tracking_object_src;
-  tracking_tracks_copy(&ctx, &object_dst->tracks, &object_src->tracks, flag);
-  tracking_plane_tracks_copy(&ctx, &object_dst->plane_tracks, &object_src->plane_tracks, flag);
-  tracking_reconstruction_copy(
-      &ctx, &object_dst->reconstruction, &object_src->reconstruction, flag);
 
-  if (object_src->active_track) {
+  tracking_tracks_copy(&ctx, &tracking_object_dst->tracks, &tracking_object_src->tracks, flag);
-    object_dst->active_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
+  tracking_plane_tracks_copy(
-                                                object_src->active_track);
+      &ctx, &tracking_object_dst->plane_tracks, &tracking_object_src->plane_tracks, flag);
-    BLI_assert(object_dst->active_track != NULL);
+  tracking_reconstruction_copy(
+      &ctx, &tracking_object_dst->reconstruction, &tracking_object_src->reconstruction, flag);
+
+  if (tracking_object_src->active_track) {
+    tracking_object_dst->active_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
+                                                         tracking_object_src->active_track);
+    BLI_assert(tracking_object_dst->active_track != NULL);
   }
-  if (object_src->active_plane_track) {
+  if (tracking_object_src->active_plane_track) {
-    object_dst->active_plane_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
+    tracking_object_dst->active_plane_track = BLI_ghash_lookup(
-                                                      object_src->active_plane_track);
+        ctx.old_to_new_track_map, tracking_object_src->active_plane_track);
-    BLI_assert(object_dst->active_plane_track != NULL);
+    BLI_assert(tracking_object_dst->active_plane_track != NULL);
   }
 
   tracking_copy_context_delete(&ctx);
 }
 
 /* Copy list of tracking objects. */
-static void tracking_objects_copy(ListBase *objects_dst,
+static void tracking_objects_copy(ListBase *tracking_objects_dst,
-                                  const ListBase *objects_src,
+                                  const ListBase *tracking_objects_src,
                                   const int flag)
 {
-  BLI_listbase_clear(objects_dst);
+  BLI_listbase_clear(tracking_objects_dst);
 
-  LISTBASE_FOREACH (MovieTrackingObject *, object_src, objects_src) {
+  LISTBASE_FOREACH (MovieTrackingObject *, tracking_object_src, tracking_objects_src) {
-    MovieTrackingObject *object_dst = MEM_mallocN(sizeof(*object_dst), __func__);
+    MovieTrackingObject *tracking_object_dst = MEM_mallocN(sizeof(*tracking_object_dst), __func__);
-    tracking_object_copy(object_dst, object_src, flag);
+    tracking_object_copy(tracking_object_dst, tracking_object_src, flag);
-    BLI_addtail(objects_dst, object_dst);
+    BLI_addtail(tracking_objects_dst, tracking_object_dst);
   }
 }
 
@@ -355,24 +357,24 @@ void BKE_tracking_settings_init(MovieTracking *tracking)
 
 ListBase *BKE_tracking_get_active_tracks(MovieTracking *tracking)
 {
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
-  BLI_assert(object != NULL);
+  BLI_assert(tracking_object != NULL);
 
-  return &object->tracks;
+  return &tracking_object->tracks;
 }
 
 ListBase *BKE_tracking_get_active_plane_tracks(MovieTracking *tracking)
 {
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
-  BLI_assert(object != NULL);
+  BLI_assert(tracking_object != NULL);
 
-  return &object->plane_tracks;
+  return &tracking_object->plane_tracks;
 }
 
 MovieTrackingReconstruction *BKE_tracking_get_active_reconstruction(MovieTracking *tracking)
 {
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
-  return &object->reconstruction;
+  return &tracking_object->reconstruction;
 }
 
 void BKE_tracking_get_camera_object_matrix(Object *camera_object, float mat[4][4])
@@ -392,7 +394,7 @@ void BKE_tracking_get_camera_object_matrix(Object *camera_object, float mat[4][4
 }
 
 void BKE_tracking_get_projection_matrix(MovieTracking *tracking,
-                                        MovieTrackingObject *object,
+                                        MovieTrackingObject *tracking_object,
                                         int framenr,
                                         int winx,
                                         int winy,
@@ -431,7 +433,7 @@ void BKE_tracking_get_projection_matrix(MovieTracking *tracking,
 
   perspective_m4(winmat, left, right, bottom, top, clipsta, clipend);
 
-  camera = BKE_tracking_camera_get_reconstructed(tracking, object, framenr);
+  camera = BKE_tracking_camera_get_reconstructed(tracking, tracking_object, framenr);
 
   if (camera) {
     float imat[4][4];
@@ -465,13 +467,13 @@ void BKE_tracking_clipboard_free(void)
 }
 
 void BKE_tracking_clipboard_copy_tracks(MovieTracking *UNUSED(tracking),
-                                        MovieTrackingObject *object)
+                                        MovieTrackingObject *tracking_object)
 {
   /* First drop all tracks from current clipboard. */
   BKE_tracking_clipboard_free();
 
   /* Then copy all selected visible tracks to it. */
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
     if (TRACK_SELECTED(track) && (track->flag & TRACK_HIDDEN) == 0) {
       MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track);
 
@@ -486,18 +488,18 @@ bool BKE_tracking_clipboard_has_tracks(void)
 }
 
 void BKE_tracking_clipboard_paste_tracks(MovieTracking *UNUSED(tracking),
-                                         MovieTrackingObject *object)
+                                         MovieTrackingObject *tracking_object)
 {
   LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_clipboard.tracks) {
     MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track);
 
     /* TODO(sergey): Preserve active track from before the copy. */
     if (track->prev == NULL) {
-      object->active_track = new_track;
+      tracking_object->active_track = new_track;
     }
 
-    BLI_addtail(&object->tracks, new_track);
+    BLI_addtail(&tracking_object->tracks, new_track);
-    BKE_tracking_track_unique_name(&object->tracks, new_track);
+    BKE_tracking_track_unique_name(&tracking_object->tracks, new_track);
   }
 }
 
@@ -1033,10 +1035,10 @@ void BKE_tracking_tracks_average(MovieTrackingTrack *dst_track,
 }
 
 MovieTrackingTrack *BKE_tracking_track_get_named(MovieTracking *UNUSED(tracking),
-                                                 MovieTrackingObject *object,
+                                                 MovieTrackingObject *tracking_object,
                                                  const char *name)
 {
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
     if (STREQ(track->name, name)) {
       return track;
     }
@@ -1679,10 +1681,10 @@ void BKE_tracking_plane_track_free(MovieTrackingPlaneTrack *plane_track)
 }
 
 MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_named(MovieTracking *UNUSED(tracking),
-                                                            MovieTrackingObject *object,
+                                                            MovieTrackingObject *tracking_object,
                                                             const char *name)
 {
-  LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &object->plane_tracks) {
+  LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &tracking_object->plane_tracks) {
     if (STREQ(plane_track->name, name)) {
       return plane_track;
     }
@@ -1971,48 +1973,49 @@ void BKE_tracking_plane_marker_get_subframe_corners(MovieTrackingPlaneTrack *pla
 
 MovieTrackingObject *BKE_tracking_object_add(MovieTracking *tracking, const char *name)
 {
-  MovieTrackingObject *object = MEM_callocN(sizeof(MovieTrackingObject), "tracking object");
+  MovieTrackingObject *tracking_object = MEM_callocN(sizeof(MovieTrackingObject),
+                                                     "tracking object");
 
   if (tracking->tot_object == 0) {
     /* first object is always camera */
-    BLI_strncpy(object->name, "Camera", sizeof(object->name));
+    BLI_strncpy(tracking_object->name, "Camera", sizeof(tracking_object->name));
 
-    object->flag |= TRACKING_OBJECT_CAMERA;
+    tracking_object->flag |= TRACKING_OBJECT_CAMERA;
   }
   else {
-    BLI_strncpy(object->name, name, sizeof(object->name));
+    BLI_strncpy(tracking_object->name, name, sizeof(tracking_object->name));
   }
 
-  BLI_addtail(&tracking->objects, object);
+  BLI_addtail(&tracking->objects, tracking_object);
 
   tracking->tot_object++;
   tracking->objectnr = BLI_listbase_count(&tracking->objects) - 1;
 
-  object->scale = 1.0f;
+  tracking_object->scale = 1.0f;
-  object->keyframe1 = 1;
+  tracking_object->keyframe1 = 1;
-  object->keyframe2 = 30;
+  tracking_object->keyframe2 = 30;
 
-  BKE_tracking_object_unique_name(tracking, object);
+  BKE_tracking_object_unique_name(tracking, tracking_object);
   BKE_tracking_dopesheet_tag_update(tracking);
 
-  return object;
+  return tracking_object;
 }
 
-bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *object)
+bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *tracking_object)
 {
-  int index = BLI_findindex(&tracking->objects, object);
+  const int index = BLI_findindex(&tracking->objects, tracking_object);
 
   if (index == -1) {
     return false;
   }
 
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
+  if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
     /* object used for camera solving can't be deleted */
     return false;
   }
 
-  tracking_object_free(object);
+  tracking_object_free(tracking_object);
-  BLI_freelinkN(&tracking->objects, object);
+  BLI_freelinkN(&tracking->objects, tracking_object);
 
   tracking->tot_object--;
 
@@ -2028,26 +2031,22 @@ bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *ob
   return true;
 }
 
-void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *object)
+void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *tracking_object)
 {
   BLI_uniquename(&tracking->objects,
-                 object,
+                 tracking_object,
                  DATA_("Object"),
                  '.',
                  offsetof(MovieTrackingObject, name),
-                 sizeof(object->name));
+                 sizeof(tracking_object->name));
 }
 
 MovieTrackingObject *BKE_tracking_object_get_named(MovieTracking *tracking, const char *name)
 {
-  MovieTrackingObject *object = tracking->objects.first;
+  LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
-
+    if (STREQ(tracking_object->name, name)) {
-  while (object) {
+      return tracking_object;
-    if (STREQ(object->name, name)) {
-      return object;
     }
-
-    object = object->next;
   }
 
   return NULL;
@@ -2060,14 +2059,10 @@ MovieTrackingObject *BKE_tracking_object_get_active(const MovieTracking *trackin
 
 MovieTrackingObject *BKE_tracking_object_get_camera(const MovieTracking *tracking)
 {
-  MovieTrackingObject *object = tracking->objects.first;
+  LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
-
+    if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
-  while (object) {
+      return tracking_object;
-    if (object->flag & TRACKING_OBJECT_CAMERA) {
-      return object;
     }
-
-    object = object->next;
   }
 
   return NULL;
@@ -2147,12 +2142,13 @@ static int reconstructed_camera_index_get(MovieTrackingReconstruction *reconstru
   return -1;
 }
 
-static void reconstructed_camera_scale_set(MovieTrackingObject *object, float mat[4][4])
+static void reconstructed_camera_scale_set(const MovieTrackingObject *tracking_object,
+                                           float mat[4][4])
 {
-  if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) {
+  if ((tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0) {
     float smat[4][4];
 
-    scale_m4_fl(smat, 1.0f / object->scale);
+    scale_m4_fl(smat, 1.0f / tracking_object->scale);
     mul_m4_m4m4(mat, mat, smat);
   }
 }
@@ -2184,11 +2180,10 @@ void BKE_tracking_camera_to_blender(
   BKE_tracking_camera_shift_get(tracking, width, height, &camera->shiftx, &camera->shifty);
 }
 
-MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(MovieTracking *UNUSED(tracking),
+MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(
-                                                                MovieTrackingObject *object,
+    MovieTracking *UNUSED(tracking), MovieTrackingObject *tracking_object, int framenr)
-                                                                int framenr)
 {
-  MovieTrackingReconstruction *reconstruction = &object->reconstruction;
+  MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
   int a = reconstructed_camera_index_get(reconstruction, framenr, false);
 
   if (a == -1) {
@@ -2199,11 +2194,11 @@ MovieReconstructedCamera *BKE_tracking_camera_get_reconstructed(MovieTracking *U
 }
 
 void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *UNUSED(tracking),
-                                                       MovieTrackingObject *object,
+                                                       MovieTrackingObject *tracking_object,
                                                        float framenr,
                                                        float mat[4][4])
 {
-  MovieTrackingReconstruction *reconstruction = &object->reconstruction;
+  MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
   MovieReconstructedCamera *cameras = reconstruction->cameras;
 
   int a = reconstructed_camera_index_get(reconstruction, (int)framenr, true);
@@ -2222,7 +2217,7 @@ void BKE_tracking_camera_get_reconstructed_interpolate(MovieTracking *UNUSED(tra
     copy_m4_m4(mat, cameras[a].mat);
   }
 
-  reconstructed_camera_scale_set(object, mat);
+  reconstructed_camera_scale_set(tracking_object, mat);
 }
 
 /* --------------------------------------------------------------------
@@ -3157,14 +3152,14 @@ static void tracking_dopesheet_channels_segments_calc(MovieTrackingDopesheetChan
 /* Create channels for tracks and calculate tracked segments for them. */
 static void tracking_dopesheet_channels_calc(MovieTracking *tracking)
 {
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
-  MovieTrackingReconstruction *reconstruction = &object->reconstruction;
+  MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
 
   bool sel_only = (dopesheet->flag & TRACKING_DOPE_SELECTED_ONLY) != 0;
   bool show_hidden = (dopesheet->flag & TRACKING_DOPE_SHOW_HIDDEN) != 0;
 
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
     if (!show_hidden && (track->flag & TRACK_HIDDEN) != 0) {
       continue;
     }
@@ -3261,13 +3256,13 @@ static int coverage_from_count(int count)
 static void tracking_dopesheet_calc_coverage(MovieTracking *tracking)
 {
   MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   int frames, start_frame = INT_MAX, end_frame = -INT_MAX;
   int *per_frame_counter;
   int prev_coverage, last_segment_frame;
 
   /* find frame boundaries */
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
     start_frame = min_ii(start_frame, track->markers[0].framenr);
     end_frame = max_ii(end_frame, track->markers[track->markersnr - 1].framenr);
   }
@@ -3283,7 +3278,7 @@ static void tracking_dopesheet_calc_coverage(MovieTracking *tracking)
   per_frame_counter = MEM_callocN(sizeof(int) * frames, "per frame track counter");
 
   /* find per-frame markers count */
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
     for (int i = 0; i < track->markersnr; i++) {
       MovieTrackingMarker *marker = &track->markers[i];
 
@@ -3369,12 +3364,10 @@ void BKE_tracking_dopesheet_update(MovieTracking *tracking)
 MovieTrackingObject *BKE_tracking_find_object_for_track(const MovieTracking *tracking,
                                                         const MovieTrackingTrack *track)
 {
-  MovieTrackingObject *object = tracking->objects.first;
+  LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
-  while (object != NULL) {
+    if (BLI_findindex(&tracking_object->tracks, track) != -1) {
-    if (BLI_findindex(&object->tracks, track) != -1) {
+      return tracking_object;
-      return object;
     }
-    object = object->next;
   }
   return NULL;
 }
@@ -3382,21 +3375,19 @@ MovieTrackingObject *BKE_tracking_find_object_for_track(const MovieTracking *tra
 ListBase *BKE_tracking_find_tracks_list_for_track(MovieTracking *tracking,
                                                   const MovieTrackingTrack *track)
 {
-  MovieTrackingObject *object = BKE_tracking_find_object_for_track(tracking, track);
+  MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(tracking, track);
-  BLI_assert(object != NULL);
+  BLI_assert(tracking_object != NULL);
 
-  return &object->tracks;
+  return &tracking_object->tracks;
 }
 
 MovieTrackingObject *BKE_tracking_find_object_for_plane_track(
     const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track)
 {
-  MovieTrackingObject *object = tracking->objects.first;
+  LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
-  while (object != NULL) {
+    if (BLI_findindex(&tracking_object->plane_tracks, plane_track) != -1) {
-    if (BLI_findindex(&object->plane_tracks, plane_track) != -1) {
+      return tracking_object;
-      return object;
     }
-    object = object->next;
   }
   return NULL;
 }
@@ -3404,10 +3395,11 @@ MovieTrackingObject *BKE_tracking_find_object_for_plane_track(
 ListBase *BKE_tracking_find_tracks_list_for_plane_track(MovieTracking *tracking,
                                                         const MovieTrackingPlaneTrack *plane_track)
 {
-  MovieTrackingObject *object = BKE_tracking_find_object_for_plane_track(tracking, plane_track);
+  MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_plane_track(tracking,
-  BLI_assert(object != NULL);
+                                                                                  plane_track);
+  BLI_assert(tracking_object != NULL);
 
-  return &object->plane_tracks;
+  return &tracking_object->plane_tracks;
 }
 
 void BKE_tracking_get_rna_path_for_track(const struct MovieTracking *tracking,
@@ -3415,15 +3407,15 @@ void BKE_tracking_get_rna_path_for_track(const struct MovieTracking *tracking,
                                          char *rna_path,
                                          size_t rna_path_len)
 {
-  MovieTrackingObject *object = BKE_tracking_find_object_for_track(tracking, track);
+  MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(tracking, track);
   char track_name_esc[MAX_NAME * 2];
   BLI_str_escape(track_name_esc, track->name, sizeof(track_name_esc));
-  if (object == NULL) {
+  if (tracking_object == NULL) {
     BLI_snprintf(rna_path, rna_path_len, "tracking.tracks[\"%s\"]", track_name_esc);
   }
   else {
     char object_name_esc[MAX_NAME * 2];
-    BLI_str_escape(object_name_esc, object->name, sizeof(object_name_esc));
+    BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc));
     BLI_snprintf(rna_path,
                  rna_path_len,
                  "tracking.objects[\"%s\"].tracks[\"%s\"]",
@@ -3437,13 +3429,13 @@ void BKE_tracking_get_rna_path_prefix_for_track(const struct MovieTracking *trac
                                                 char *rna_path,
                                                 size_t rna_path_len)
 {
-  MovieTrackingObject *object = BKE_tracking_find_object_for_track(tracking, track);
+  MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_track(tracking, track);
-  if (object == NULL) {
+  if (tracking_object == NULL) {
     BLI_strncpy(rna_path, "tracking.tracks", rna_path_len);
   }
   else {
     char object_name_esc[MAX_NAME * 2];
-    BLI_str_escape(object_name_esc, object->name, sizeof(object_name_esc));
+    BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc));
     BLI_snprintf(rna_path, rna_path_len, "tracking.objects[\"%s\"]", object_name_esc);
   }
 }
@@ -3453,15 +3445,16 @@ void BKE_tracking_get_rna_path_for_plane_track(const struct MovieTracking *track
                                                char *rna_path,
                                                size_t rna_path_len)
 {
-  MovieTrackingObject *object = BKE_tracking_find_object_for_plane_track(tracking, plane_track);
+  MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_plane_track(tracking,
+                                                                                  plane_track);
   char track_name_esc[MAX_NAME * 2];
   BLI_str_escape(track_name_esc, plane_track->name, sizeof(track_name_esc));
-  if (object == NULL) {
+  if (tracking_object == NULL) {
     BLI_snprintf(rna_path, rna_path_len, "tracking.plane_tracks[\"%s\"]", track_name_esc);
   }
   else {
     char object_name_esc[MAX_NAME * 2];
-    BLI_str_escape(object_name_esc, object->name, sizeof(object_name_esc));
+    BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc));
     BLI_snprintf(rna_path,
                  rna_path_len,
                  "tracking.objects[\"%s\"].plane_tracks[\"%s\"]",
@@ -3476,13 +3469,14 @@ void BKE_tracking_get_rna_path_prefix_for_plane_track(
     char *rna_path,
     size_t rna_path_len)
 {
-  MovieTrackingObject *object = BKE_tracking_find_object_for_plane_track(tracking, plane_track);
+  MovieTrackingObject *tracking_object = BKE_tracking_find_object_for_plane_track(tracking,
-  if (object == NULL) {
+                                                                                  plane_track);
+  if (tracking_object == NULL) {
     BLI_strncpy(rna_path, "tracking.plane_tracks", rna_path_len);
   }
   else {
     char object_name_esc[MAX_NAME * 2];
-    BLI_str_escape(object_name_esc, object->name, sizeof(object_name_esc));
+    BLI_str_escape(object_name_esc, tracking_object->name, sizeof(object_name_esc));
     BLI_snprintf(rna_path, rna_path_len, "tracking.objects[\"%s\"].plane_tracks", object_name_esc);
   }
 }

source/blender/blenkernel/intern/tracking_solver.c

@@ -131,14 +131,15 @@ static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context,
   int sfra = context->sfra, efra = context->efra;
   float imat[4][4];
 
-  MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking,
-  MovieTrackingReconstruction *reconstruction = &object->reconstruction;
+                                                                       context->object_name);
+  MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
 
   unit_m4(imat);
 
   {
     int track_index = 0;
-    LISTBASE_FOREACH_INDEX (MovieTrackingTrack *, track, &object->tracks, track_index) {
+    LISTBASE_FOREACH_INDEX (MovieTrackingTrack *, track, &tracking_object->tracks, track_index) {
       double pos[3];
 
       if (libmv_reprojectionPointForTrack(libmv_reconstruction, track_index, pos)) {
@@ -221,7 +222,7 @@ static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context,
   }
 
   if (origin_set) {
-    LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
+    LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
       if (track->flag & TRACK_HAS_BUNDLE) {
         mul_v3_m4v3(track->bundle_pos, imat, track->bundle_pos);
       }
@@ -244,12 +245,12 @@ static int reconstruct_retrieve_libmv(MovieReconstructContext *context, MovieTra
 
 /* Convert blender's refinement flags to libmv's. */
 static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking,
-                                                   MovieTrackingObject *object)
+                                                   MovieTrackingObject *tracking_object)
 {
-  int refine = tracking->settings.refine_camera_intrinsics;
+  const int refine = tracking->settings.refine_camera_intrinsics;
   int flags = 0;
 
-  if ((object->flag & TRACKING_OBJECT_CAMERA) == 0) {
+  if ((tracking_object->flag & TRACKING_OBJECT_CAMERA) == 0) {
     return 0;
   }
 
@@ -273,12 +274,12 @@ static int reconstruct_refine_intrinsics_get_flags(MovieTracking *tracking,
 }
 
 /* Count tracks which has markers at both of keyframes. */
-static int reconstruct_count_tracks_on_both_keyframes(MovieTrackingObject *object)
+static int reconstruct_count_tracks_on_both_keyframes(MovieTrackingObject *tracking_object)
 {
-  const int frame1 = object->keyframe1, frame2 = object->keyframe2;
+  const int frame1 = tracking_object->keyframe1, frame2 = tracking_object->keyframe2;
 
   int tot = 0;
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
     if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame1)) {
       if (BKE_tracking_track_has_enabled_marker_at_frame(track, frame2)) {
         tot++;
@@ -290,7 +291,7 @@ static int reconstruct_count_tracks_on_both_keyframes(MovieTrackingObject *objec
 }
 
 bool BKE_tracking_reconstruction_check(MovieTracking *tracking,
-                                       MovieTrackingObject *object,
+                                       MovieTrackingObject *tracking_object,
                                        char *error_msg,
                                        int error_size)
 {
@@ -300,7 +301,7 @@ bool BKE_tracking_reconstruction_check(MovieTracking *tracking,
   }
   if ((tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) == 0) {
     /* automatic keyframe selection does not require any pre-process checks */
-    if (reconstruct_count_tracks_on_both_keyframes(object) < 8) {
+    if (reconstruct_count_tracks_on_both_keyframes(tracking_object) < 8) {
       BLI_strncpy(error_msg,
                   N_("At least 8 common tracks on both keyframes are needed for reconstruction"),
                   error_size);
@@ -317,21 +318,22 @@ bool BKE_tracking_reconstruction_check(MovieTracking *tracking,
   return true;
 }
 
-MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip,
+MovieReconstructContext *BKE_tracking_reconstruction_context_new(
-                                                                 MovieTrackingObject *object,
+    MovieClip *clip,
-                                                                 int keyframe1,
+    MovieTrackingObject *tracking_object,
-                                                                 int keyframe2,
+    int keyframe1,
-                                                                 int width,
+    int keyframe2,
-                                                                 int height)
+    int width,
+    int height)
 {
   MovieTracking *tracking = &clip->tracking;
   MovieReconstructContext *context = MEM_callocN(sizeof(MovieReconstructContext),
                                                  "MovieReconstructContext data");
   const float aspy = 1.0f / tracking->camera.pixel_aspect;
-  const int num_tracks = BLI_listbase_count(&object->tracks);
+  const int num_tracks = BLI_listbase_count(&tracking_object->tracks);
   int sfra = INT_MAX, efra = INT_MIN;
 
-  BLI_strncpy(context->object_name, object->name, sizeof(context->object_name));
+  BLI_strncpy(context->object_name, tracking_object->name, sizeof(context->object_name));
   context->motion_flag = tracking->settings.motion_flag;
 
   context->select_keyframes = (tracking->settings.reconstruction_flag &
@@ -342,7 +344,7 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
 
   context->tracks_map = tracks_map_new(context->object_name, num_tracks, 0);
 
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
     int first = 0, last = track->markersnr - 1;
     MovieTrackingMarker *first_marker = &track->markers[0];
     MovieTrackingMarker *last_marker = &track->markers[track->markersnr - 1];
@@ -373,10 +375,10 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
   context->sfra = sfra;
   context->efra = efra;
 
-  context->tracks = libmv_tracks_new(clip, &object->tracks, width, height * aspy);
+  context->tracks = libmv_tracks_new(clip, &tracking_object->tracks, width, height * aspy);
   context->keyframe1 = keyframe1;
   context->keyframe2 = keyframe2;
-  context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, object);
+  context->refine_flags = reconstruct_refine_intrinsics_get_flags(tracking, tracking_object);
 
   context->error_message[0] = '\0';
 
@@ -495,13 +497,14 @@ bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieT
   tracks_map_merge(context->tracks_map, tracking);
   BKE_tracking_dopesheet_tag_update(tracking);
 
-  MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking,
-  MovieTrackingReconstruction *reconstruction = &object->reconstruction;
+                                                                       context->object_name);
+  MovieTrackingReconstruction *reconstruction = &tracking_object->reconstruction;
 
   /* update keyframe in the interface */
   if (context->select_keyframes) {
-    object->keyframe1 = context->keyframe1;
+    tracking_object->keyframe1 = context->keyframe1;
-    object->keyframe2 = context->keyframe2;
+    tracking_object->keyframe2 = context->keyframe2;
   }
 
   reconstruction->error = context->reprojection_error;

source/blender/blenkernel/intern/tracking_util.c

@@ -110,13 +110,13 @@ void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
   ListBase tracks = {NULL, NULL}, new_tracks = {NULL, NULL};
   ListBase *old_tracks;
 
-  MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking, map->object_name);
-  if (!object) {
+  if (!tracking_object) {
     /* object was deleted by user, create new one */
-    object = BKE_tracking_object_add(tracking, map->object_name);
+    tracking_object = BKE_tracking_object_add(tracking, map->object_name);
   }
 
-  old_tracks = &object->tracks;
+  old_tracks = &tracking_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

source/blender/blenloader/intern/versioning_260.c

@@ -1732,18 +1732,13 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
   }
 
   if (!MAIN_VERSION_ATLEAST(bmain, 264, 7)) {
-    MovieClip *clip;
+    LISTBASE_FOREACH (MovieClip *, clip, &bmain->movieclips) {
-
+      LISTBASE_FOREACH (MovieTrackingTrack *, track, &clip->tracking.tracks_legacy) {
-    for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
-      MovieTrackingTrack *track;
-      MovieTrackingObject *object;
-
-      for (track = clip->tracking.tracks_legacy.first; track; track = track->next) {
         do_versions_affine_tracker_track(track);
       }
 
-      for (object = clip->tracking.objects.first; object; object = object->next) {
+      LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &clip->tracking.objects) {
-        for (track = object->tracks.first; track; track = track->next) {
+        LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
           do_versions_affine_tracker_track(track);
         }
       }

source/blender/compositor/operations/COM_PlaneTrackOperation.cc

@@ -42,19 +42,17 @@ void PlaneTrackCommon::read_and_calculate_corners(PlaneDistortBaseOperation *dis
 
 void PlaneTrackCommon::read_corners_from_track(float corners[4][2], float frame)
 {
-  MovieTracking *tracking;
-  MovieTrackingObject *object;
-
   if (!movie_clip_) {
     return;
   }
 
-  tracking = &movie_clip_->tracking;
+  MovieTracking *tracking = &movie_clip_->tracking;
 
-  object = BKE_tracking_object_get_named(tracking, tracking_object_name_);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking,
-  if (object) {
+                                                                       tracking_object_name_);
+  if (tracking_object) {
     MovieTrackingPlaneTrack *plane_track;
-    plane_track = BKE_tracking_plane_track_get_named(tracking, object, plane_track_name_);
+    plane_track = BKE_tracking_plane_track_get_named(tracking, tracking_object, plane_track_name_);
     if (plane_track) {
       float clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(movie_clip_, frame);
       BKE_tracking_plane_marker_get_subframe_corners(plane_track, clip_framenr, corners);

source/blender/compositor/operations/COM_TrackPositionOperation.cc

@@ -36,9 +36,7 @@ void TrackPositionOperation::init_execution()
 void TrackPositionOperation::calc_track_position()
 {
   is_track_position_calculated_ = true;
-  MovieTracking *tracking = nullptr;
   MovieClipUser user = *DNA_struct_default_get(MovieClipUser);
-  MovieTrackingObject *object;
 
   track_position_ = 0;
   zero_v2(marker_pos_);
@@ -48,16 +46,16 @@ void TrackPositionOperation::calc_track_position()
     return;
   }
 
-  tracking = &movie_clip_->tracking;
+  MovieTracking *tracking = &movie_clip_->tracking;
 
   BKE_movieclip_user_set_frame(&user, framenumber_);
   BKE_movieclip_get_size(movie_clip_, &user, &width_, &height_);
 
-  object = BKE_tracking_object_get_named(tracking, tracking_object_name_);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking,
-  if (object) {
+                                                                       tracking_object_name_);
-    MovieTrackingTrack *track;
+  if (tracking_object) {
-
+    MovieTrackingTrack *track = BKE_tracking_track_get_named(
-    track = BKE_tracking_track_get_named(tracking, object, track_name_);
+        tracking, tracking_object, track_name_);
 
     if (track) {
       MovieTrackingMarker *marker;

source/blender/editors/space_clip/clip_dopesheet_ops.c

@@ -62,7 +62,7 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
   SpaceClip *sc = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(sc);
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
   float location[2];
   const bool extend = RNA_boolean_get(op->ptr, "extend");
@@ -84,8 +84,8 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
       }
 
       if (track->flag & TRACK_DOPE_SEL) {
-        object->active_track = track;
+        tracking_object->active_track = track;
-        BKE_tracking_track_select(&object->tracks, track, TRACK_AREA_ALL, true);
+        BKE_tracking_track_select(&tracking_object->tracks, track, TRACK_AREA_ALL, true);
       }
       else if (show_selected_only == false) {
         BKE_tracking_track_deselect(track, TRACK_AREA_ALL);

source/blender/editors/space_clip/clip_draw.c

@@ -1592,13 +1592,13 @@ static void draw_tracking_tracks(SpaceClip *sc,
   }
 
   if (sc->flag & SC_SHOW_BUNDLES) {
-    MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+    MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
     float pos[4], vec[4], mat[4][4], aspy;
 
     GPU_point_size(3.0f);
 
     aspy = 1.0f / clip->tracking.camera.pixel_aspect;
-    BKE_tracking_get_projection_matrix(tracking, object, framenr, width, height, mat);
+    BKE_tracking_get_projection_matrix(tracking, tracking_object, framenr, width, height, mat);
 
     track = tracksbase->first;
     while (track) {

source/blender/editors/space_clip/clip_graph_ops.c

@@ -247,11 +247,11 @@ static bool mouse_select_curve(bContext *C, const float co[2], bool extend)
     }
     else if (act_track != userdata.track) {
       SelectUserData selectdata = {SEL_DESELECT};
-      MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+      MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
-      object->active_track = userdata.track;
+      tracking_object->active_track = userdata.track;
       if ((sc->flag & SC_SHOW_GRAPH_SEL_ONLY) == 0) {
-        BKE_tracking_track_select(&object->tracks, userdata.track, TRACK_AREA_ALL, false);
+        BKE_tracking_track_select(&tracking_object->tracks, userdata.track, TRACK_AREA_ALL, false);
       }
 
       /* deselect all knots on newly selected curve */

source/blender/editors/space_clip/tracking_ops.c

@@ -1619,15 +1619,15 @@ static int set_solver_keyframe_exec(bContext *C, wmOperator *op)
   SpaceClip *sc = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(sc);
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
-  int keyframe = RNA_enum_get(op->ptr, "keyframe");
+  const int keyframe = RNA_enum_get(op->ptr, "keyframe");
-  int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, sc->user.framenr);
+  const int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, sc->user.framenr);
 
   if (keyframe == SOLVER_KEYFRAME_A) {
-    object->keyframe1 = framenr;
+    tracking_object->keyframe1 = framenr;
   }
   else {
-    object->keyframe2 = framenr;
+    tracking_object->keyframe2 = framenr;
   }
 
   WM_event_add_notifier(C, NC_MOVIECLIP | ND_DISPLAY, clip);
@@ -1992,16 +1992,14 @@ static int tracking_object_remove_exec(bContext *C, wmOperator *op)
   SpaceClip *sc = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(sc);
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object;
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
-  object = BKE_tracking_object_get_active(tracking);
+  if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
-
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
     BKE_report(op->reports, RPT_WARNING, "Object used for camera tracking cannot be deleted");
     return OPERATOR_CANCELLED;
   }
 
-  BKE_tracking_object_delete(tracking, object);
+  BKE_tracking_object_delete(tracking, tracking_object);
 
   DEG_id_tag_update(&clip->id, ID_RECALC_COPY_ON_WRITE);
   WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
@@ -2035,11 +2033,11 @@ static int copy_tracks_exec(bContext *C, wmOperator *UNUSED(op))
   SpaceClip *sc = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(sc);
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
   clip_tracking_clear_invisible_track_selection(sc, clip);
 
-  BKE_tracking_clipboard_copy_tracks(tracking, object);
+  BKE_tracking_clipboard_copy_tracks(tracking, tracking_object);
 
   return OPERATOR_FINISHED;
 }

source/blender/editors/space_clip/tracking_ops_solve.c

@@ -53,10 +53,10 @@ static bool solve_camera_initjob(
   MovieClip *clip = ED_space_clip_get_clip(sc);
   Scene *scene = CTX_data_scene(C);
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   int width, height;
 
-  if (!BKE_tracking_reconstruction_check(tracking, object, error_msg, max_error)) {
+  if (!BKE_tracking_reconstruction_check(tracking, tracking_object, error_msg, max_error)) {
     return false;
   }
 
@@ -69,8 +69,12 @@ static bool solve_camera_initjob(
   scj->reports = op->reports;
   scj->user = sc->user;
 
-  scj->context = BKE_tracking_reconstruction_context_new(
+  scj->context = BKE_tracking_reconstruction_context_new(clip,
-      clip, object, object->keyframe1, object->keyframe2, width, height);
+                                                         tracking_object,
+                                                         tracking_object->keyframe1,
+                                                         tracking_object->keyframe2,
+                                                         width,
+                                                         height);
 
   tracking->stats = MEM_callocN(sizeof(MovieTrackingStats), "solve camera stats");
 

source/blender/makesrna/intern/rna_mask.c

@@ -59,14 +59,15 @@ static void rna_Mask_update_parent(Main *bmain, Scene *scene, PointerRNA *ptr)
     if (GS(parent->id->name) == ID_MC) {
       MovieClip *clip = (MovieClip *)parent->id;
       MovieTracking *tracking = &clip->tracking;
-      MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, parent->parent);
+      MovieTrackingObject *tracking_object = BKE_tracking_object_get_named(tracking,
+                                                                           parent->parent);
 
-      if (object) {
+      if (tracking_object) {
         int clip_framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, scene->r.cfra);
 
         if (parent->type == MASK_PARENT_POINT_TRACK) {
           MovieTrackingTrack *track = BKE_tracking_track_get_named(
-              tracking, object, parent->sub_parent);
+              tracking, tracking_object, parent->sub_parent);
 
           if (track) {
             MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_framenr);
@@ -84,7 +85,7 @@ static void rna_Mask_update_parent(Main *bmain, Scene *scene, PointerRNA *ptr)
         }
         else /* if (parent->type == MASK_PARENT_PLANE_TRACK) */ {
           MovieTrackingPlaneTrack *plane_track = BKE_tracking_plane_track_get_named(
-              tracking, object, parent->sub_parent);
+              tracking, tracking_object, parent->sub_parent);
           if (plane_track) {
             MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track,
                                                                                    clip_framenr);

source/blender/makesrna/intern/rna_tracking.c

@@ -434,30 +434,31 @@ static void rna_tracking_resetIntrinsics(Main *UNUSED(bmain),
 
 static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
-  MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
+  MovieTrackingObject *tracking_object = (MovieTrackingObject *)ptr->data;
-  rna_iterator_listbase_begin(iter, &object->tracks, NULL);
+  rna_iterator_listbase_begin(iter, &tracking_object->tracks, NULL);
 }
 
 static void rna_trackingObject_plane_tracks_begin(CollectionPropertyIterator *iter,
                                                   PointerRNA *ptr)
 {
-  MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
+  MovieTrackingObject *tracking_object = (MovieTrackingObject *)ptr->data;
-  rna_iterator_listbase_begin(iter, &object->plane_tracks, NULL);
+  rna_iterator_listbase_begin(iter, &tracking_object->plane_tracks, NULL);
 }
 
 static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr)
 {
-  MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
+  MovieTrackingObject *tracking_object = (MovieTrackingObject *)ptr->data;
   return rna_pointer_inherit_refine(
-      ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
+      ptr, &RNA_MovieTrackingReconstruction, &tracking_object->reconstruction);
 }
 
 static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
-  MovieTrackingObject *object = BLI_findlink(&clip->tracking.objects, clip->tracking.objectnr);
+  MovieTrackingObject *tracking_object = BLI_findlink(&clip->tracking.objects,
+                                                      clip->tracking.objectnr);
 
-  return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, object);
+  return rna_pointer_inherit_refine(ptr, &RNA_MovieTrackingObject, tracking_object);
 }
 
 static void rna_tracking_active_object_set(PointerRNA *ptr,
@@ -465,8 +466,8 @@ static void rna_tracking_active_object_set(PointerRNA *ptr,
                                            struct ReportList *UNUSED(reports))
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
-  MovieTrackingObject *object = (MovieTrackingObject *)value.data;
+  MovieTrackingObject *tracking_object = (MovieTrackingObject *)value.data;
-  int index = BLI_findindex(&clip->tracking.objects, object);
+  const int index = BLI_findindex(&clip->tracking.objects, tracking_object);
 
   if (index != -1) {
     clip->tracking.objectnr = index;
@@ -479,11 +480,11 @@ static void rna_tracking_active_object_set(PointerRNA *ptr,
 static void rna_trackingObject_name_set(PointerRNA *ptr, const char *value)
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
-  MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
+  MovieTrackingObject *tracking_object = (MovieTrackingObject *)ptr->data;
 
-  BLI_strncpy(object->name, value, sizeof(object->name));
+  BLI_strncpy(tracking_object->name, value, sizeof(tracking_object->name));
 
-  BKE_tracking_object_unique_name(&clip->tracking, object);
+  BKE_tracking_object_unique_name(&clip->tracking, tracking_object);
 }
 
 static void rna_trackingObject_flushUpdate(Main *UNUSED(bmain),
@@ -603,13 +604,13 @@ static MovieTrackingTrack *rna_trackingTracks_new(ID *id,
 }
 
 static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id,
-                                                         MovieTrackingObject *object,
+                                                         MovieTrackingObject *tracking_object,
                                                          const char *name,
                                                          int frame)
 {
   MovieClip *clip = (MovieClip *)id;
   MovieTrackingTrack *track = add_track_to_base(
-      clip, &clip->tracking, &object->tracks, name, frame);
+      clip, &clip->tracking, &tracking_object->tracks, name, frame);
 
   WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
 
@@ -618,20 +619,20 @@ static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id,
 
 static MovieTrackingObject *rna_trackingObject_new(MovieTracking *tracking, const char *name)
 {
-  MovieTrackingObject *object = BKE_tracking_object_add(tracking, name);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_add(tracking, name);
 
   WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
 
-  return object;
+  return tracking_object;
 }
 
 static void rna_trackingObject_remove(MovieTracking *tracking,
                                       ReportList *reports,
                                       PointerRNA *object_ptr)
 {
-  MovieTrackingObject *object = object_ptr->data;
+  MovieTrackingObject *tracking_object = object_ptr->data;
-  if (BKE_tracking_object_delete(tracking, object) == false) {
+  if (BKE_tracking_object_delete(tracking, tracking_object) == false) {
-    BKE_reportf(reports, RPT_ERROR, "MovieTracking '%s' cannot be removed", object->name);
+    BKE_reportf(reports, RPT_ERROR, "MovieTracking '%s' cannot be removed", tracking_object->name);
     return;
   }
 
@@ -735,11 +736,9 @@ static void rna_trackingPlaneMarkers_delete_frame(MovieTrackingPlaneTrack *plane
 static MovieTrackingObject *find_object_for_reconstruction(
     MovieTracking *tracking, MovieTrackingReconstruction *reconstruction)
 {
-  MovieTrackingObject *object;
+  LISTBASE_FOREACH (MovieTrackingObject *, tracking_object, &tracking->objects) {
-
+    if (&tracking_object->reconstruction == reconstruction) {
-  for (object = tracking->objects.first; object; object = object->next) {
+      return tracking_object;
-    if (&object->reconstruction == reconstruction) {
-      return object;
     }
   }
 
@@ -751,8 +750,8 @@ static MovieReconstructedCamera *rna_trackingCameras_find_frame(
 {
   MovieClip *clip = (MovieClip *)id;
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object = find_object_for_reconstruction(tracking, reconstruction);
+  MovieTrackingObject *tracking_object = find_object_for_reconstruction(tracking, reconstruction);
-  return BKE_tracking_camera_get_reconstructed(tracking, object, framenr);
+  return BKE_tracking_camera_get_reconstructed(tracking, tracking_object, framenr);
 }
 
 static void rna_trackingCameras_matrix_from_frame(ID *id,
@@ -764,8 +763,8 @@ static void rna_trackingCameras_matrix_from_frame(ID *id,
 
   MovieClip *clip = (MovieClip *)id;
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object = find_object_for_reconstruction(tracking, reconstruction);
+  MovieTrackingObject *tracking_object = find_object_for_reconstruction(tracking, reconstruction);
-  BKE_tracking_camera_get_reconstructed_interpolate(tracking, object, framenr, mat);
+  BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, mat);
 
   memcpy(matrix, mat, sizeof(float[4][4]));
 }

source/blender/nodes/composite/nodes/node_composite_planetrackdeform.cc

@@ -79,7 +79,7 @@ static void node_composit_buts_planetrackdeform(uiLayout *layout, bContext *C, P
   if (node->id) {
     MovieClip *clip = (MovieClip *)node->id;
     MovieTracking *tracking = &clip->tracking;
-    MovieTrackingObject *object;
+    MovieTrackingObject *tracking_object;
     uiLayout *col;
     PointerRNA tracking_ptr;
 
@@ -88,11 +88,11 @@ static void node_composit_buts_planetrackdeform(uiLayout *layout, bContext *C, P
     col = uiLayoutColumn(layout, false);
     uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA);
 
-    object = BKE_tracking_object_get_named(tracking, data->tracking_object);
+    tracking_object = BKE_tracking_object_get_named(tracking, data->tracking_object);
-    if (object) {
+    if (tracking_object) {
       PointerRNA object_ptr;
 
-      RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, object, &object_ptr);
+      RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, tracking_object, &object_ptr);
 
       uiItemPointerR(
           col, ptr, "plane_track_name", &object_ptr, "plane_tracks", "", ICON_ANIM_DATA);

source/blender/nodes/composite/nodes/node_composite_trackpos.cc

@@ -74,7 +74,7 @@ static void node_composit_buts_trackpos(uiLayout *layout, bContext *C, PointerRN
   if (node->id) {
     MovieClip *clip = (MovieClip *)node->id;
     MovieTracking *tracking = &clip->tracking;
-    MovieTrackingObject *object;
+    MovieTrackingObject *tracking_object;
     uiLayout *col;
     PointerRNA tracking_ptr;
     NodeTrackPosData *data = (NodeTrackPosData *)node->storage;
@@ -84,11 +84,11 @@ static void node_composit_buts_trackpos(uiLayout *layout, bContext *C, PointerRN
     col = uiLayoutColumn(layout, false);
     uiItemPointerR(col, ptr, "tracking_object", &tracking_ptr, "objects", "", ICON_OBJECT_DATA);
 
-    object = BKE_tracking_object_get_named(tracking, data->tracking_object);
+    tracking_object = BKE_tracking_object_get_named(tracking, data->tracking_object);
-    if (object) {
+    if (tracking_object) {
       PointerRNA object_ptr;
 
-      RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, object, &object_ptr);
+      RNA_pointer_create(&clip->id, &RNA_MovieTrackingObject, tracking_object, &object_ptr);
 
       uiItemPointerR(col, ptr, "track_name", &object_ptr, "tracks", "", ICON_ANIM_DATA);
     }