diff --git a/source/blender/blenkernel/BKE_tracking.h b/source/blender/blenkernel/BKE_tracking.h
index 32de8545313..b34403b3033 100644
--- a/source/blender/blenkernel/BKE_tracking.h
+++ b/source/blender/blenkernel/BKE_tracking.h
@@ -839,7 +839,7 @@ void BKE_tracking_get_rna_path_prefix_for_plane_track(
 
 #define MARKER_VISIBLE(sc, track, marker) \
   (((marker)->flag & MARKER_DISABLED) == 0 || ((sc)->flag & SC_HIDE_DISABLED) == 0 || \
-   ((sc)->clip->tracking.act_track == track))
+   (BKE_tracking_track_get_active(&(sc)->clip->tracking) == track))
 
 #ifdef __cplusplus
 }
diff --git a/source/blender/blenkernel/intern/movieclip.c b/source/blender/blenkernel/intern/movieclip.c
index 9945f896972..dd2a9f582cf 100644
--- a/source/blender/blenkernel/intern/movieclip.c
+++ b/source/blender/blenkernel/intern/movieclip.c
@@ -69,6 +69,10 @@
 
 #include "BLO_read_write.h"
 
+/* Convert camera object to legacy format where the camera tracks are stored in the MovieTracking
+ * structure when saving .blend file. */
+#define USE_LEGACY_CAMERA_OBJECT_FORMAT_ON_SAVE 1
+
 static void free_buffers(MovieClip *clip);
 
 static void movie_clip_init_data(ID *id)
@@ -117,18 +121,11 @@ static void movie_clip_foreach_id(ID *id, LibraryForeachIDData *data)
 
   BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, movie_clip->gpd, IDWALK_CB_USER);
 
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
-    BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, track->gpd, IDWALK_CB_USER);
-  }
   LISTBASE_FOREACH (MovieTrackingObject *, object, &tracking->objects) {
     LISTBASE_FOREACH (MovieTrackingTrack *, track, &object->tracks) {
       BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, track->gpd, IDWALK_CB_USER);
     }
   }
-
-  LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &tracking->plane_tracks) {
-    BKE_LIB_FOREACHID_PROCESS_IDSUPER(data, plane_track->image, IDWALK_CB_USER);
-  }
 }
 
 static void movie_clip_foreach_cache(ID *id,
@@ -200,7 +197,29 @@ static void movieclip_blend_write(BlendWriter *writer, ID *id, const void *id_ad
   clip->tracking.stats = NULL;
 
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingObject *object;
+
+#if USE_LEGACY_CAMERA_OBJECT_FORMAT_ON_SAVE
+  const bool is_undo = BLO_write_is_undo(writer);
+
+  /* When using legacy format for camera object assign the list of camera tracks to the
+   * MovieTracking object. Do it in-place as it simplifies the code a bit, and it is not
+   * supposed to cause threading issues as no other code is meant to access the legacy fields. */
+  if (!is_undo) {
+    MovieTrackingObject *active_tracking_object = BKE_tracking_object_get_active(tracking);
+    MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(tracking);
+    BLI_assert(active_tracking_object != NULL);
+    BLI_assert(tracking_camera_object != NULL);
+
+    tracking->tracks_legacy = tracking_camera_object->tracks;
+    tracking->plane_tracks_legacy = tracking_camera_object->plane_tracks;
+
+    /* The active track in the tracking structure used to be shared across all tracking objects. */
+    tracking->act_track_legacy = active_tracking_object->active_track;
+    tracking->act_plane_track_legacy = active_tracking_object->active_plane_track;
+
+    tracking->reconstruction_legacy = tracking_camera_object->reconstruction;
+  }
+#endif
 
   BLO_write_id_struct(writer, MovieClip, id_address, &clip->id);
   BKE_id_blend_write(writer, &clip->id);
@@ -209,20 +228,40 @@ static void movieclip_blend_write(BlendWriter *writer, ID *id, const void *id_ad
     BKE_animdata_blend_write(writer, clip->adt);
   }
 
-  write_movieTracks(writer, &tracking->tracks);
-  write_moviePlaneTracks(writer, &tracking->plane_tracks);
-  write_movieReconstruction(writer, &tracking->reconstruction);
-
-  object = tracking->objects.first;
-  while (object) {
-    BLO_write_struct(writer, MovieTrackingObject, object);
+  LISTBASE_FOREACH (MovieTrackingObject *, object, &tracking->objects) {
+#if USE_LEGACY_CAMERA_OBJECT_FORMAT_ON_SAVE
+    /* When saving camers object in the legacy format clear the list of tracks. This is because the
+     * tracking object code is generic and assumes object owns the tracks in the list. For the
+     * camera tracks that is not the case in the legacy format. */
+    if (!is_undo && (object->flag & TRACKING_OBJECT_CAMERA)) {
+      MovieTrackingObject legacy_object = *object;
+      BLI_listbase_clear(&legacy_object.tracks);
+      BLI_listbase_clear(&legacy_object.plane_tracks);
+      legacy_object.active_track = NULL;
+      legacy_object.active_plane_track = NULL;
+      memset(&legacy_object.reconstruction, 0, sizeof(legacy_object.reconstruction));
+      BLO_write_struct_at_address(writer, MovieTrackingObject, object, &legacy_object);
+    }
+    else
+#endif
+    {
+      BLO_write_struct(writer, MovieTrackingObject, object);
+    }
 
     write_movieTracks(writer, &object->tracks);
     write_moviePlaneTracks(writer, &object->plane_tracks);
     write_movieReconstruction(writer, &object->reconstruction);
-
-    object = object->next;
   }
+
+#if USE_LEGACY_CAMERA_OBJECT_FORMAT_ON_SAVE
+  if (!is_undo) {
+    BLI_listbase_clear(&tracking->tracks_legacy);
+    BLI_listbase_clear(&tracking->plane_tracks_legacy);
+    tracking->act_track_legacy = NULL;
+    tracking->act_plane_track_legacy = NULL;
+    memset(&tracking->reconstruction_legacy, 0, sizeof(tracking->reconstruction_legacy));
+  }
+#endif
 }
 
 static void direct_link_movieReconstruction(BlendDataReader *reader,
@@ -262,12 +301,12 @@ static void movieclip_blend_read_data(BlendDataReader *reader, ID *id)
   BLO_read_data_address(reader, &clip->adt);
   BKE_animdata_blend_read_data(reader, clip->adt);
 
-  direct_link_movieTracks(reader, &tracking->tracks);
-  direct_link_moviePlaneTracks(reader, &tracking->plane_tracks);
-  direct_link_movieReconstruction(reader, &tracking->reconstruction);
+  direct_link_movieTracks(reader, &tracking->tracks_legacy);
+  direct_link_moviePlaneTracks(reader, &tracking->plane_tracks_legacy);
+  direct_link_movieReconstruction(reader, &tracking->reconstruction_legacy);
 
-  BLO_read_data_address(reader, &clip->tracking.act_track);
-  BLO_read_data_address(reader, &clip->tracking.act_plane_track);
+  BLO_read_data_address(reader, &clip->tracking.act_track_legacy);
+  BLO_read_data_address(reader, &clip->tracking.act_plane_track_legacy);
 
   clip->anim = NULL;
   clip->tracking_context = NULL;
@@ -290,6 +329,9 @@ static void movieclip_blend_read_data(BlendDataReader *reader, ID *id)
     direct_link_movieTracks(reader, &object->tracks);
     direct_link_moviePlaneTracks(reader, &object->plane_tracks);
     direct_link_movieReconstruction(reader, &object->reconstruction);
+
+    BLO_read_data_address(reader, &object->active_track);
+    BLO_read_data_address(reader, &object->active_plane_track);
   }
 }
 
@@ -316,9 +358,6 @@ static void movieclip_blend_read_lib(BlendLibReader *reader, ID *id)
 
   BLO_read_id_address(reader, clip->id.lib, &clip->gpd);
 
-  lib_link_movieTracks(reader, clip, &tracking->tracks);
-  lib_link_moviePlaneTracks(reader, clip, &tracking->plane_tracks);
-
   LISTBASE_FOREACH (MovieTrackingObject *, object, &tracking->objects) {
     lib_link_movieTracks(reader, clip, &object->tracks);
     lib_link_moviePlaneTracks(reader, clip, &object->plane_tracks);
diff --git a/source/blender/blenkernel/intern/tracking.c b/source/blender/blenkernel/intern/tracking.c
index 2a7ebe2a421..b953c160dbc 100644
--- a/source/blender/blenkernel/intern/tracking.c
+++ b/source/blender/blenkernel/intern/tracking.c
@@ -149,9 +149,6 @@ static void tracking_dopesheet_free(MovieTrackingDopesheet *dopesheet)
 
 void BKE_tracking_free(MovieTracking *tracking)
 {
-  tracking_tracks_free(&tracking->tracks);
-  tracking_plane_tracks_free(&tracking->plane_tracks);
-  tracking_reconstruction_free(&tracking->reconstruction);
   tracking_objects_free(&tracking->objects);
 
   if (tracking->camera.intrinsics) {
@@ -247,8 +244,7 @@ static void tracking_reconstruction_copy(TrackingCopyContext *UNUSED(ctx),
 }
 
 /* Copy stabilization structure. */
-static void tracking_stabilization_copy(TrackingCopyContext *UNUSED(ctx),
-                                        MovieTrackingStabilization *stabilization_dst,
+static void tracking_stabilization_copy(MovieTrackingStabilization *stabilization_dst,
                                         const MovieTrackingStabilization *stabilization_src,
                                         const int UNUSED(flag))
 {
@@ -268,6 +264,17 @@ static void tracking_object_copy(MovieTrackingObject *object_dst,
   tracking_reconstruction_copy(
       &ctx, &object_dst->reconstruction, &object_src->reconstruction, flag);
 
+  if (object_src->active_track) {
+    object_dst->active_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
+                                                object_src->active_track);
+    BLI_assert(object_dst->active_track != NULL);
+  }
+  if (object_src->active_plane_track) {
+    object_dst->active_plane_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
+                                                      object_src->active_plane_track);
+    BLI_assert(object_dst->active_plane_track != NULL);
+  }
+
   tracking_copy_context_delete(&ctx);
 }
 
@@ -291,25 +298,7 @@ void BKE_tracking_copy(MovieTracking *tracking_dst,
 {
   *tracking_dst = *tracking_src;
 
-  TrackingCopyContext ctx = tracking_copy_context_new();
-  tracking_tracks_copy(&ctx, &tracking_dst->tracks, &tracking_src->tracks, flag);
-  tracking_plane_tracks_copy(&ctx, &tracking_dst->plane_tracks, &tracking_src->plane_tracks, flag);
-  tracking_reconstruction_copy(
-      &ctx, &tracking_dst->reconstruction, &tracking_src->reconstruction, flag);
-  tracking_stabilization_copy(
-      &ctx, &tracking_dst->stabilization, &tracking_src->stabilization, flag);
-
-  if (tracking_src->act_track) {
-    tracking_dst->act_track = BLI_ghash_lookup(ctx.old_to_new_track_map, tracking_src->act_track);
-    BLI_assert(tracking_dst->act_track != NULL);
-  }
-  if (tracking_src->act_plane_track) {
-    tracking_dst->act_plane_track = BLI_ghash_lookup(ctx.old_to_new_track_map,
-                                                     tracking_src->act_plane_track);
-    BLI_assert(tracking_dst->act_plane_track != NULL);
-  }
-
-  tracking_copy_context_delete(&ctx);
+  tracking_stabilization_copy(&tracking_dst->stabilization, &tracking_src->stabilization, flag);
 
   tracking_objects_copy(&tracking_dst->objects, &tracking_src->objects, flag);
 
@@ -367,23 +356,17 @@ void BKE_tracking_settings_init(MovieTracking *tracking)
 ListBase *BKE_tracking_get_active_tracks(MovieTracking *tracking)
 {
   MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  BLI_assert(object != NULL);
 
-  if (object && (object->flag & TRACKING_OBJECT_CAMERA) == 0) {
-    return &object->tracks;
-  }
-
-  return &tracking->tracks;
+  return &object->tracks;
 }
 
 ListBase *BKE_tracking_get_active_plane_tracks(MovieTracking *tracking)
 {
   MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
+  BLI_assert(object != NULL);
 
-  if (object && (object->flag & TRACKING_OBJECT_CAMERA) == 0) {
-    return &object->plane_tracks;
-  }
-
-  return &tracking->plane_tracks;
+  return &object->plane_tracks;
 }
 
 MovieTrackingReconstruction *BKE_tracking_get_active_reconstruction(MovieTracking *tracking)
@@ -514,8 +497,10 @@ void BKE_tracking_clipboard_paste_tracks(MovieTracking *tracking, MovieTrackingO
 
   while (track) {
     MovieTrackingTrack *new_track = BKE_tracking_track_duplicate(track);
+
+    /* TODO(sergey): Preserve active track from before the copy. */
     if (track->prev == NULL) {
-      tracking->act_track = new_track;
+      object->active_track = new_track;
     }
 
     BLI_addtail(tracksbase, new_track);
@@ -1109,20 +1094,15 @@ MovieTrackingTrack *BKE_tracking_track_get_indexed(MovieTracking *tracking,
 
 MovieTrackingTrack *BKE_tracking_track_get_active(MovieTracking *tracking)
 {
-  ListBase *tracksbase;
-
-  if (!tracking->act_track) {
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
+  if (tracking_object->active_track == NULL) {
     return NULL;
   }
 
-  tracksbase = BKE_tracking_get_active_tracks(tracking);
+  /* Perform data consistency check. */
+  BLI_assert(BLI_findindex(&tracking_object->tracks, tracking_object->active_track) != -1);
 
-  /* check that active track is in current tracks list */
-  if (BLI_findindex(tracksbase, tracking->act_track) != -1) {
-    return tracking->act_track;
-  }
-
-  return NULL;
+  return tracking_object->active_track;
 }
 
 static bGPDlayer *track_mask_gpencil_layer_get(const MovieTrackingTrack *track)
@@ -1738,18 +1718,16 @@ MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_named(MovieTracking *track
 
 MovieTrackingPlaneTrack *BKE_tracking_plane_track_get_active(struct MovieTracking *tracking)
 {
-  if (tracking->act_plane_track == NULL) {
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
+  if (tracking_object->active_plane_track == NULL) {
     return NULL;
   }
 
-  ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
+  /* Perform data consistency check. */
+  BLI_assert(BLI_findindex(&tracking_object->plane_tracks, tracking_object->active_plane_track) !=
+             -1);
 
-  /* Check that active track is in current plane tracks list */
-  if (BLI_findindex(plane_tracks_base, tracking->act_plane_track) != -1) {
-    return tracking->act_plane_track;
-  }
-
-  return NULL;
+  return tracking_object->active_plane_track;
 }
 
 void BKE_tracking_plane_tracks_deselect_all(ListBase *plane_tracks_base)
@@ -2047,7 +2025,6 @@ MovieTrackingObject *BKE_tracking_object_add(MovieTracking *tracking, const char
 
 bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *object)
 {
-  MovieTrackingTrack *track;
   int index = BLI_findindex(&tracking->objects, object);
 
   if (index == -1) {
@@ -2059,15 +2036,6 @@ bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *ob
     return false;
   }
 
-  track = object->tracks.first;
-  while (track) {
-    if (track == tracking->act_track) {
-      tracking->act_track = NULL;
-    }
-
-    track = track->next;
-  }
-
   tracking_object_free(object);
   BLI_freelinkN(&tracking->objects, object);
 
@@ -2130,32 +2098,21 @@ MovieTrackingObject *BKE_tracking_object_get_camera(const MovieTracking *trackin
   return NULL;
 }
 
-ListBase *BKE_tracking_object_get_tracks(MovieTracking *tracking, MovieTrackingObject *object)
+ListBase *BKE_tracking_object_get_tracks(MovieTracking *UNUSED(tracking),
+                                         MovieTrackingObject *object)
 {
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
-    return &tracking->tracks;
-  }
-
   return &object->tracks;
 }
 
-ListBase *BKE_tracking_object_get_plane_tracks(MovieTracking *tracking,
+ListBase *BKE_tracking_object_get_plane_tracks(MovieTracking *UNUSED(tracking),
                                                MovieTrackingObject *object)
 {
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
-    return &tracking->plane_tracks;
-  }
-
   return &object->plane_tracks;
 }
 
-MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(MovieTracking *tracking,
-                                                                    MovieTrackingObject *object)
+MovieTrackingReconstruction *BKE_tracking_object_get_reconstruction(
+    MovieTracking *UNUSED(tracking), MovieTrackingObject *object)
 {
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
-    return &tracking->reconstruction;
-  }
-
   return &object->reconstruction;
 }
 
@@ -3464,10 +3421,6 @@ void BKE_tracking_dopesheet_update(MovieTracking *tracking)
 MovieTrackingObject *BKE_tracking_find_object_for_track(const MovieTracking *tracking,
                                                         const MovieTrackingTrack *track)
 {
-  const ListBase *tracksbase = &tracking->tracks;
-  if (BLI_findindex(tracksbase, track) != -1) {
-    return NULL;
-  }
   MovieTrackingObject *object = tracking->objects.first;
   while (object != NULL) {
     if (BLI_findindex(&object->tracks, track) != -1) {
@@ -3482,19 +3435,14 @@ ListBase *BKE_tracking_find_tracks_list_for_track(MovieTracking *tracking,
                                                   const MovieTrackingTrack *track)
 {
   MovieTrackingObject *object = BKE_tracking_find_object_for_track(tracking, track);
-  if (object != NULL) {
-    return &object->tracks;
-  }
-  return &tracking->tracks;
+  BLI_assert(object != NULL);
+
+  return &object->tracks;
 }
 
 MovieTrackingObject *BKE_tracking_find_object_for_plane_track(
     const MovieTracking *tracking, const MovieTrackingPlaneTrack *plane_track)
 {
-  const ListBase *plane_tracks_base = &tracking->plane_tracks;
-  if (BLI_findindex(plane_tracks_base, plane_track) != -1) {
-    return NULL;
-  }
   MovieTrackingObject *object = tracking->objects.first;
   while (object != NULL) {
     if (BLI_findindex(&object->plane_tracks, plane_track) != -1) {
@@ -3509,10 +3457,9 @@ 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);
-  if (object != NULL) {
-    return &object->plane_tracks;
-  }
-  return &tracking->plane_tracks;
+  BLI_assert(object != NULL);
+
+  return &object->plane_tracks;
 }
 
 void BKE_tracking_get_rna_path_for_track(const struct MovieTracking *tracking,
diff --git a/source/blender/blenkernel/intern/tracking_solver.c b/source/blender/blenkernel/intern/tracking_solver.c
index e784c39ba08..6a492ea1cb7 100644
--- a/source/blender/blenkernel/intern/tracking_solver.c
+++ b/source/blender/blenkernel/intern/tracking_solver.c
@@ -40,7 +40,6 @@ typedef struct MovieReconstructContext {
   struct libmv_Reconstruction *reconstruction;
 
   char object_name[MAX_NAME];
-  bool is_camera;
   short motion_flag;
 
   libmv_CameraIntrinsicsOptions camera_intrinsics_options;
@@ -137,16 +136,10 @@ static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context,
   int sfra = context->sfra, efra = context->efra;
   float imat[4][4];
 
-  if (context->is_camera) {
-    tracksbase = &tracking->tracks;
-    reconstruction = &tracking->reconstruction;
-  }
-  else {
-    MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
+  MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, context->object_name);
 
-    tracksbase = &object->tracks;
-    reconstruction = &object->reconstruction;
-  }
+  tracksbase = &object->tracks;
+  reconstruction = &object->reconstruction;
 
   unit_m4(imat);
 
@@ -355,7 +348,6 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
   MovieTrackingTrack *track;
 
   BLI_strncpy(context->object_name, object->name, sizeof(context->object_name));
-  context->is_camera = object->flag & TRACKING_OBJECT_CAMERA;
   context->motion_flag = tracking->settings.motion_flag;
 
   context->select_keyframes = (tracking->settings.reconstruction_flag &
@@ -364,7 +356,7 @@ MovieReconstructContext *BKE_tracking_reconstruction_context_new(MovieClip *clip
   tracking_cameraIntrinscisOptionsFromTracking(
       tracking, width, height, &context->camera_intrinsics_options);
 
-  context->tracks_map = tracks_map_new(context->object_name, context->is_camera, num_tracks, 0);
+  context->tracks_map = tracks_map_new(context->object_name, num_tracks, 0);
 
   track = tracksbase->first;
   while (track) {
@@ -526,13 +518,7 @@ bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieT
   BKE_tracking_dopesheet_tag_update(tracking);
 
   object = BKE_tracking_object_get_named(tracking, context->object_name);
-
-  if (context->is_camera) {
-    reconstruction = &tracking->reconstruction;
-  }
-  else {
-    reconstruction = &object->reconstruction;
-  }
+  reconstruction = &object->reconstruction;
 
   /* update keyframe in the interface */
   if (context->select_keyframes) {
diff --git a/source/blender/blenkernel/intern/tracking_stabilize.c b/source/blender/blenkernel/intern/tracking_stabilize.c
index b03d226964c..b9abd5f494c 100644
--- a/source/blender/blenkernel/intern/tracking_stabilize.c
+++ b/source/blender/blenkernel/intern/tracking_stabilize.c
@@ -302,7 +302,9 @@ static void find_next_working_frames(StabContext *ctx,
                                      int *next_lower,
                                      int *next_higher)
 {
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &ctx->tracking->tracks) {
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(ctx->tracking);
+
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
     if (is_usable_for_stabilization(ctx, track)) {
       int startpoint = search_closest_marker_index(track, framenr);
       retrieve_next_higher_usable_frame(ctx, track, startpoint, framenr, next_higher);
@@ -514,6 +516,7 @@ static bool average_track_contributions(StabContext *ctx,
   float weight_sum;
   MovieTracking *tracking = ctx->tracking;
   MovieTrackingStabilization *stab = &tracking->stabilization;
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(ctx->tracking);
   float ref_pos[2];
   BLI_assert(stab->flag & TRACKING_2D_STABILIZATION);
 
@@ -525,7 +528,7 @@ static bool average_track_contributions(StabContext *ctx,
 
   ok = false;
   weight_sum = 0.0f;
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
     if (!is_init_for_stabilization(ctx, track)) {
       continue;
     }
@@ -563,7 +566,7 @@ static bool average_track_contributions(StabContext *ctx,
 
   ok = false;
   weight_sum = 0.0f;
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
     if (!is_init_for_stabilization(ctx, track)) {
       continue;
     }
@@ -618,11 +621,11 @@ static void average_marker_positions(StabContext *ctx, int framenr, float r_ref_
 {
   bool ok = false;
   float weight_sum;
-  MovieTracking *tracking = ctx->tracking;
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(ctx->tracking);
 
   zero_v2(r_ref_pos);
   weight_sum = 0.0f;
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
     if (track->flag & TRACK_USE_2D_STAB) {
       float weight = 0.0f;
       MovieTrackingMarker *marker = get_tracking_data_point(ctx, track, framenr, &weight);
@@ -645,7 +648,7 @@ static void average_marker_positions(StabContext *ctx, int framenr, float r_ref_
     int next_lower = MINAFRAME;
     int next_higher = MAXFRAME;
     use_values_from_fcurves(ctx, true);
-    LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
+    LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
       /* NOTE: we deliberately do not care if this track
        *       is already initialized for stabilization. */
       if (track->flag & TRACK_USE_2D_STAB) {
@@ -737,9 +740,10 @@ static int establish_track_initialization_order(StabContext *ctx, TrackInitOrder
 {
   size_t tracknr = 0;
   MovieTracking *tracking = ctx->tracking;
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(tracking);
   int anchor_frame = tracking->stabilization.anchor_frame;
 
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
     MovieTrackingMarker *marker;
     order[tracknr].data = track;
     marker = get_closest_marker(ctx, track, anchor_frame);
@@ -847,6 +851,7 @@ static void init_all_tracks(StabContext *ctx, float aspect)
   size_t track_len = 0;
   MovieClip *clip = ctx->clip;
   MovieTracking *tracking = ctx->tracking;
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(tracking);
   TrackInitOrder *order;
 
   /* Attempt to start initialization at anchor_frame.
@@ -859,7 +864,7 @@ static void init_all_tracks(StabContext *ctx, float aspect)
   zero_v2(pivot);
 
   /* Initialize private working data. */
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
     TrackStabilizationBase *local_data = access_stabilization_baseline_data(ctx, track);
     if (!local_data) {
       local_data = MEM_callocN(sizeof(TrackStabilizationBase),
@@ -1102,6 +1107,7 @@ static void stabilization_data_to_mat4(float pixel_aspect,
 static float calculate_autoscale_factor(StabContext *ctx, int size, float aspect)
 {
   MovieTrackingStabilization *stab = ctx->stab;
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(ctx->tracking);
   float pixel_aspect = ctx->tracking->camera.pixel_aspect;
   int height = size, width = aspect * size;
 
@@ -1109,7 +1115,7 @@ static float calculate_autoscale_factor(StabContext *ctx, int size, float aspect
   float scale = 1.0f, scale_step = 0.0f;
 
   /* Calculate maximal frame range of tracks where stabilization is active. */
-  LISTBASE_FOREACH (MovieTrackingTrack *, track, &ctx->tracking->tracks) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_camera_object->tracks) {
     if ((track->flag & TRACK_USE_2D_STAB) ||
         ((stab->flag & TRACKING_STABILIZE_ROTATION) && (track->flag & TRACK_USE_2D_STAB_ROT))) {
       int first_frame = track->markers[0].framenr;
diff --git a/source/blender/blenkernel/intern/tracking_util.c b/source/blender/blenkernel/intern/tracking_util.c
index aaf262d120b..a1637b63d82 100644
--- a/source/blender/blenkernel/intern/tracking_util.c
+++ b/source/blender/blenkernel/intern/tracking_util.c
@@ -48,15 +48,11 @@
 /** \name Tracks Map
  * \{ */
 
-TracksMap *tracks_map_new(const char *object_name,
-                          bool is_camera,
-                          int num_tracks,
-                          int customdata_size)
+TracksMap *tracks_map_new(const char *object_name, int num_tracks, int customdata_size)
 {
   TracksMap *map = MEM_callocN(sizeof(TracksMap), "TrackingsMap");
 
   BLI_strncpy(map->object_name, object_name, sizeof(map->object_name));
-  map->is_camera = is_camera;
 
   map->num_tracks = num_tracks;
   map->customdata_size = customdata_size;
@@ -114,19 +110,13 @@ void tracks_map_merge(TracksMap *map, MovieTracking *tracking)
   ListBase tracks = {NULL, NULL}, new_tracks = {NULL, NULL};
   ListBase *old_tracks;
 
-  if (map->is_camera) {
-    old_tracks = &tracking->tracks;
+  MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name);
+  if (!object) {
+    /* object was deleted by user, create new one */
+    object = BKE_tracking_object_add(tracking, map->object_name);
   }
-  else {
-    MovieTrackingObject *object = BKE_tracking_object_get_named(tracking, map->object_name);
 
-    if (!object) {
-      /* object was deleted by user, create new one */
-      object = BKE_tracking_object_add(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
diff --git a/source/blender/blenkernel/tracking_private.h b/source/blender/blenkernel/tracking_private.h
index ef507633ac9..9400f16a458 100644
--- a/source/blender/blenkernel/tracking_private.h
+++ b/source/blender/blenkernel/tracking_private.h
@@ -26,7 +26,6 @@ struct libmv_CameraIntrinsicsOptions;
 
 typedef struct TracksMap {
   char object_name[MAX_NAME];
-  bool is_camera;
 
   int num_tracks;
   int customdata_size;
@@ -42,10 +41,7 @@ typedef struct TracksMap {
   SpinLock spin_lock;
 } TracksMap;
 
-struct TracksMap *tracks_map_new(const char *object_name,
-                                 bool is_camera,
-                                 int num_tracks,
-                                 int customdata_size);
+struct TracksMap *tracks_map_new(const char *object_name, int num_tracks, int customdata_size);
 int tracks_map_get_size(struct TracksMap *map);
 void tracks_map_get_indexed_element(struct TracksMap *map,
                                     int index,
diff --git a/source/blender/blenloader/intern/versioning_260.c b/source/blender/blenloader/intern/versioning_260.c
index 504de311f7e..08b53d646ff 100644
--- a/source/blender/blenloader/intern/versioning_260.c
+++ b/source/blender/blenloader/intern/versioning_260.c
@@ -856,7 +856,7 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
           clip->tracking.camera.pixel_aspect = 1.0f;
         }
 
-        track = clip->tracking.tracks.first;
+        track = clip->tracking.tracks_legacy.first;
         while (track) {
           if (track->minimum_correlation == 0.0f) {
             track->minimum_correlation = 0.75f;
@@ -1442,7 +1442,7 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
     for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
       MovieTrackingTrack *track;
 
-      track = clip->tracking.tracks.first;
+      track = clip->tracking.tracks_legacy.first;
       while (track) {
         do_versions_affine_tracker_track(track);
 
@@ -1738,7 +1738,7 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
       MovieTrackingTrack *track;
       MovieTrackingObject *object;
 
-      for (track = clip->tracking.tracks.first; track; track = track->next) {
+      for (track = clip->tracking.tracks_legacy.first; track; track = track->next) {
         do_versions_affine_tracker_track(track);
       }
 
@@ -2459,7 +2459,7 @@ void blo_do_versions_260(FileData *fd, Library *UNUSED(lib), Main *bmain)
       MovieClip *clip;
       for (clip = bmain->movieclips.first; clip; clip = clip->id.next) {
         MovieTrackingPlaneTrack *plane_track;
-        for (plane_track = clip->tracking.plane_tracks.first; plane_track;
+        for (plane_track = clip->tracking.plane_tracks_legacy.first; plane_track;
              plane_track = plane_track->next) {
           plane_track->image_opacity = 1.0f;
         }
diff --git a/source/blender/blenloader/intern/versioning_400.cc b/source/blender/blenloader/intern/versioning_400.cc
index 2616bb890a3..910ac6456b6 100644
--- a/source/blender/blenloader/intern/versioning_400.cc
+++ b/source/blender/blenloader/intern/versioning_400.cc
@@ -8,8 +8,14 @@
 
 #include "CLG_log.h"
 
+#include "DNA_movieclip_types.h"
+
+#include "BLI_assert.h"
+#include "BLI_listbase.h"
+
 #include "BKE_main.h"
 #include "BKE_mesh_legacy_convert.h"
+#include "BKE_tracking.h"
 
 #include "BLO_readfile.h"
 
@@ -29,6 +35,47 @@ static void version_mesh_legacy_to_struct_of_array_format(Mesh &mesh)
   BKE_mesh_legacy_edge_crease_to_layers(&mesh);
 }
 
+static void version_motion_tracking_legacy_camera_object(MovieClip &movieclip)
+{
+  MovieTracking &tracking = movieclip.tracking;
+  MovieTrackingObject *active_tracking_object = BKE_tracking_object_get_active(&tracking);
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&tracking);
+
+  /* Sanity check.
+   * The camera tracking object is not supposed to have tracking and reconstruction read into it
+   * yet. */
+
+  BLI_assert(tracking_camera_object != nullptr);
+  BLI_assert(BLI_listbase_is_empty(&tracking_camera_object->tracks));
+  BLI_assert(BLI_listbase_is_empty(&tracking_camera_object->plane_tracks));
+  BLI_assert(tracking_camera_object->reconstruction.cameras == nullptr);
+
+  /* Move storage from tracking to the actual tracking object. */
+
+  tracking_camera_object->tracks = tracking.tracks_legacy;
+  tracking_camera_object->plane_tracks = tracking.plane_tracks_legacy;
+
+  tracking_camera_object->reconstruction = tracking.reconstruction_legacy;
+  memset(&tracking.reconstruction_legacy, 0, sizeof(tracking.reconstruction_legacy));
+
+  /* The active track in the tracking structure used to be shared across all tracking objects. */
+  active_tracking_object->active_track = tracking.act_track_legacy;
+  active_tracking_object->active_plane_track = tracking.act_plane_track_legacy;
+
+  /* Clear pointers in the legacy storage. */
+  BLI_listbase_clear(&tracking.tracks_legacy);
+  BLI_listbase_clear(&tracking.plane_tracks_legacy);
+  tracking.act_track_legacy = nullptr;
+  tracking.act_plane_track_legacy = nullptr;
+}
+
+void version_movieclips_legacy_camera_object(Main *bmain)
+{
+  LISTBASE_FOREACH (MovieClip *, movieclip, &bmain->movieclips) {
+    version_motion_tracking_legacy_camera_object(*movieclip);
+  }
+}
+
 void blo_do_versions_400(FileData * /*fd*/, Library * /*lib*/, Main *bmain)
 {
   // if (!MAIN_VERSION_ATLEAST(bmain, 400, 0)) {
@@ -38,6 +85,7 @@ void blo_do_versions_400(FileData * /*fd*/, Library * /*lib*/, Main *bmain)
   LISTBASE_FOREACH (Mesh *, mesh, &bmain->meshes) {
     version_mesh_legacy_to_struct_of_array_format(*mesh);
   }
+  version_movieclips_legacy_camera_object(bmain);
   // }
 
   /**
diff --git a/source/blender/editors/space_clip/clip_dopesheet_ops.c b/source/blender/editors/space_clip/clip_dopesheet_ops.c
index 731d963364d..a6fdef32846 100644
--- a/source/blender/editors/space_clip/clip_dopesheet_ops.c
+++ b/source/blender/editors/space_clip/clip_dopesheet_ops.c
@@ -86,7 +86,7 @@ static int dopesheet_select_channel_exec(bContext *C, wmOperator *op)
       }
 
       if (track->flag & TRACK_DOPE_SEL) {
-        tracking->act_track = track;
+        object->active_track = track;
         BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, true);
       }
       else if (show_selected_only == false) {
diff --git a/source/blender/editors/space_clip/clip_graph_ops.c b/source/blender/editors/space_clip/clip_graph_ops.c
index 67565a88bab..ce718bbd1c0 100644
--- a/source/blender/editors/space_clip/clip_graph_ops.c
+++ b/source/blender/editors/space_clip/clip_graph_ops.c
@@ -249,10 +249,9 @@ static bool mouse_select_curve(bContext *C, const float co[2], bool extend)
       SelectUserData selectdata = {SEL_DESELECT};
       MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
 
-      tracking->act_track = userdata.track;
+      object->active_track = userdata.track;
       if ((sc->flag & SC_SHOW_GRAPH_SEL_ONLY) == 0) {
-        ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, object);
-        BKE_tracking_track_select(tracksbase, userdata.track, TRACK_AREA_ALL, false);
+        BKE_tracking_track_select(&object->tracks, userdata.track, TRACK_AREA_ALL, false);
       }
 
       /* deselect all knots on newly selected curve */
diff --git a/source/blender/editors/space_clip/clip_utils.c b/source/blender/editors/space_clip/clip_utils.c
index 04b87cb4c83..9d1b4a6417c 100644
--- a/source/blender/editors/space_clip/clip_utils.c
+++ b/source/blender/editors/space_clip/clip_utils.c
@@ -311,13 +311,12 @@ void clip_graph_tracking_iterate(SpaceClip *sc,
 void clip_delete_track(bContext *C, MovieClip *clip, MovieTrackingTrack *track)
 {
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
-  ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   bool has_bundle = false;
   const bool used_for_stabilization = (track->flag &
                                        (TRACK_USE_2D_STAB | TRACK_USE_2D_STAB_ROT)) != 0;
-  if (track == act_track) {
-    tracking->act_track = NULL;
+  if (track == tracking_object->active_track) {
+    tracking_object->active_track = NULL;
   }
   /* Handle reconstruction display in 3d viewport. */
   if (track->flag & TRACK_HAS_BUNDLE) {
@@ -334,7 +333,7 @@ void clip_delete_track(bContext *C, MovieClip *clip, MovieTrackingTrack *track)
   }
   /* Delete track itself. */
   BKE_tracking_track_free(track);
-  BLI_freelinkN(tracksbase, track);
+  BLI_freelinkN(&tracking_object->tracks, track);
   /* Send notifiers. */
   WM_event_add_notifier(C, NC_MOVIECLIP | NA_EDITED, clip);
   if (used_for_stabilization) {
diff --git a/source/blender/editors/space_clip/tracking_ops.c b/source/blender/editors/space_clip/tracking_ops.c
index 49725a26562..5e2c1a26266 100644
--- a/source/blender/editors/space_clip/tracking_ops.c
+++ b/source/blender/editors/space_clip/tracking_ops.c
@@ -49,8 +49,7 @@ static bool add_marker(const bContext *C, float x, float y)
   SpaceClip *sc = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(sc);
   MovieTracking *tracking = &clip->tracking;
-  ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
-  ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   MovieTrackingTrack *track;
   int width, height;
   int framenr = ED_space_clip_get_clip_frame_number(sc);
@@ -61,13 +60,13 @@ static bool add_marker(const bContext *C, float x, float y)
     return false;
   }
 
-  track = BKE_tracking_track_add(tracking, tracksbase, x, y, framenr, width, height);
+  track = BKE_tracking_track_add(tracking, &tracking_object->tracks, x, y, framenr, width, height);
 
-  BKE_tracking_track_select(tracksbase, track, TRACK_AREA_ALL, 0);
-  BKE_tracking_plane_tracks_deselect_all(plane_tracks_base);
+  BKE_tracking_track_select(&tracking_object->tracks, track, TRACK_AREA_ALL, 0);
+  BKE_tracking_plane_tracks_deselect_all(&tracking_object->plane_tracks);
 
-  clip->tracking.act_track = track;
-  clip->tracking.act_plane_track = NULL;
+  tracking_object->active_track = track;
+  tracking_object->active_plane_track = NULL;
 
   return true;
 }
@@ -683,9 +682,10 @@ static int slide_marker_invoke(bContext *C, wmOperator *op, const wmEvent *event
     SpaceClip *sc = CTX_wm_space_clip(C);
     MovieClip *clip = ED_space_clip_get_clip(sc);
     MovieTracking *tracking = &clip->tracking;
+    MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
-    tracking->act_track = slidedata->track;
-    tracking->act_plane_track = NULL;
+    tracking_object->active_track = slidedata->track;
+    tracking_object->active_plane_track = NULL;
 
     op->customdata = slidedata;
 
@@ -1136,14 +1136,13 @@ static int hide_tracks_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 *tracking_object = BKE_tracking_object_get_active(tracking);
   int unselected;
 
   unselected = RNA_boolean_get(op->ptr, "unselected");
 
   /* Hide point tracks. */
-  ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
-  MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
-  for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) {
+  LISTBASE_FOREACH (MovieTrackingTrack *, track, &tracking_object->tracks) {
     if (unselected == 0 && TRACK_VIEW_SELECTED(sc, track)) {
       track->flag |= TRACK_HIDDEN;
     }
@@ -1152,15 +1151,13 @@ static int hide_tracks_exec(bContext *C, wmOperator *op)
     }
   }
 
-  if (act_track != NULL && act_track->flag & TRACK_HIDDEN) {
-    clip->tracking.act_track = NULL;
+  const MovieTrackingTrack *active_track = tracking_object->active_track;
+  if (active_track != NULL && active_track->flag & TRACK_HIDDEN) {
+    tracking_object->active_track = NULL;
   }
 
   /* Hide place tracks. */
-  ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
-  MovieTrackingPlaneTrack *act_plane_track = BKE_tracking_plane_track_get_active(tracking);
-  for (MovieTrackingPlaneTrack *plane_track = plane_tracks_base->first; plane_track != NULL;
-       plane_track = plane_track->next) {
+  LISTBASE_FOREACH (MovieTrackingPlaneTrack *, plane_track, &tracking_object->plane_tracks) {
     if (unselected == 0 && plane_track->flag & SELECT) {
       plane_track->flag |= PLANE_TRACK_HIDDEN;
     }
@@ -1168,8 +1165,10 @@ static int hide_tracks_exec(bContext *C, wmOperator *op)
       plane_track->flag |= PLANE_TRACK_HIDDEN;
     }
   }
-  if (act_plane_track != NULL && act_plane_track->flag & TRACK_HIDDEN) {
-    clip->tracking.act_plane_track = NULL;
+
+  const MovieTrackingPlaneTrack *active_plane_track = tracking_object->active_plane_track;
+  if (active_plane_track != NULL && active_plane_track->flag & TRACK_HIDDEN) {
+    tracking_object->active_plane_track = NULL;
   }
 
   BKE_tracking_dopesheet_tag_update(tracking);
@@ -1261,6 +1260,7 @@ static int frame_jump_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 *tracking_object = BKE_tracking_object_get_active(tracking);
   int pos = RNA_enum_get(op->ptr, "position");
   int delta;
 
@@ -1284,16 +1284,15 @@ static int frame_jump_exec(bContext *C, wmOperator *op)
     }
   }
   else { /* to failed frame */
-    if (tracking->reconstruction.flag & TRACKING_RECONSTRUCTED) {
+    if (tracking_object->reconstruction.flag & TRACKING_RECONSTRUCTED) {
       int framenr = ED_space_clip_get_clip_frame_number(sc);
-      MovieTrackingObject *object = BKE_tracking_object_get_active(tracking);
 
       delta = pos == 3 ? 1 : -1;
       framenr += delta;
 
       while (framenr + delta >= scene->r.sfra && framenr + delta <= scene->r.efra) {
         MovieReconstructedCamera *cam = BKE_tracking_camera_get_reconstructed(
-            tracking, object, framenr);
+            tracking, tracking_object, framenr);
 
         if (cam == NULL) {
           sc->user.framenr = BKE_movieclip_remap_clip_to_scene_frame(clip, framenr);
@@ -1454,6 +1453,7 @@ static int average_tracks_exec(bContext *C, wmOperator *op)
   SpaceClip *space_clip = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(space_clip);
   MovieTracking *tracking = &clip->tracking;
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
   /* Collect source tracks. */
   int num_source_tracks;
@@ -1465,8 +1465,8 @@ static int average_tracks_exec(bContext *C, wmOperator *op)
 
   /* Create new empty track, which will be the averaged result.
    * Makes it simple to average all selection  to it. */
-  ListBase *tracks_list = BKE_tracking_get_active_tracks(tracking);
-  MovieTrackingTrack *result_track = BKE_tracking_track_add_empty(tracking, tracks_list);
+  MovieTrackingTrack *result_track = BKE_tracking_track_add_empty(tracking,
+                                                                  &tracking_object->tracks);
 
   /* Perform averaging. */
   BKE_tracking_tracks_average(result_track, source_tracks, num_source_tracks);
@@ -1481,12 +1481,12 @@ static int average_tracks_exec(bContext *C, wmOperator *op)
   /* Update selection, making the result track active and selected. */
   /* TODO(sergey): Should become some sort of utility function available for all operators. */
 
-  BKE_tracking_track_select(tracks_list, result_track, TRACK_AREA_ALL, 0);
+  BKE_tracking_track_select(&tracking_object->tracks, result_track, TRACK_AREA_ALL, 0);
   ListBase *plane_tracks_list = BKE_tracking_get_active_plane_tracks(tracking);
   BKE_tracking_plane_tracks_deselect_all(plane_tracks_list);
 
-  clip->tracking.act_track = result_track;
-  clip->tracking.act_plane_track = NULL;
+  tracking_object->active_track = result_track;
+  tracking_object->active_plane_track = NULL;
 
   /* Inform the dependency graph and interface about changes. */
   DEG_id_tag_update(&clip->id, 0);
@@ -1830,8 +1830,7 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
   SpaceClip *sc = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(sc);
   MovieTracking *tracking = &clip->tracking;
-  ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
-  MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   int frames = RNA_int_get(op->ptr, "frames");
   int action = RNA_enum_get(op->ptr, "action");
   float error = RNA_float_get(op->ptr, "error");
@@ -1840,10 +1839,7 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
     action = TRACKING_CLEAN_DELETE_TRACK;
   }
 
-  for (MovieTrackingTrack *track = tracksbase->first, *next_track; track != NULL;
-       track = next_track) {
-    next_track = track->next;
-
+  LISTBASE_FOREACH_MUTABLE (MovieTrackingTrack *, track, &tracking_object->tracks) {
     if ((track->flag & TRACK_HIDDEN) == 0 && (track->flag & TRACK_LOCKED) == 0) {
       bool ok;
 
@@ -1855,21 +1851,21 @@ static int clean_tracks_exec(bContext *C, wmOperator *op)
           BKE_tracking_track_flag_set(track, TRACK_AREA_ALL, SELECT);
         }
         else if (action == TRACKING_CLEAN_DELETE_TRACK) {
-          if (track == act_track) {
-            clip->tracking.act_track = NULL;
+          if (track == tracking_object->active_track) {
+            tracking_object->active_track = NULL;
           }
           BKE_tracking_track_free(track);
-          BLI_freelinkN(tracksbase, track);
+          BLI_freelinkN(&tracking_object->tracks, track);
           track = NULL;
         }
 
         /* Happens when all tracking segments are not long enough. */
         if (track && track->markersnr == 0) {
-          if (track == act_track) {
-            clip->tracking.act_track = NULL;
+          if (track == tracking_object->active_track) {
+            tracking_object->active_track = NULL;
           }
           BKE_tracking_track_free(track);
-          BLI_freelinkN(tracksbase, track);
+          BLI_freelinkN(&tracking_object->tracks, track);
         }
       }
     }
@@ -2231,9 +2227,9 @@ static ImBuf *sample_plane_marker_image_for_operator(bContext *C)
   MovieClip *clip = ED_space_clip_get_clip(space_clip);
 
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingPlaneTrack *plane_track = tracking->act_plane_track;
-  const MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(plane_track,
-                                                                               clip_frame_number);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
+  const MovieTrackingPlaneMarker *plane_marker = BKE_tracking_plane_marker_get(
+      tracking_object->active_plane_track, clip_frame_number);
 
   ImBuf *frame_ibuf = ED_space_clip_get_buffer(space_clip);
   if (frame_ibuf == NULL) {
@@ -2256,8 +2252,9 @@ static bool new_image_from_plane_marker_poll(bContext *C)
   SpaceClip *space_clip = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(space_clip);
   const MovieTracking *tracking = &clip->tracking;
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
-  if (tracking->act_plane_track == NULL) {
+  if (tracking_object->active_plane_track == NULL) {
     return false;
   }
 
@@ -2269,7 +2266,8 @@ static int new_image_from_plane_marker_exec(bContext *C, wmOperator *UNUSED(op))
   SpaceClip *space_clip = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(space_clip);
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingPlaneTrack *plane_track = tracking->act_plane_track;
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingPlaneTrack *plane_track = tracking_object->active_plane_track;
 
   ImBuf *plane_ibuf = sample_plane_marker_image_for_operator(C);
   if (plane_ibuf == NULL) {
@@ -2309,12 +2307,14 @@ static bool update_image_from_plane_marker_poll(bContext *C)
   SpaceClip *space_clip = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(space_clip);
   const MovieTracking *tracking = &clip->tracking;
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
-  if (tracking->act_plane_track == NULL || tracking->act_plane_track->image == NULL) {
+  if (tracking_object->active_plane_track == NULL ||
+      tracking_object->active_plane_track->image == NULL) {
     return false;
   }
 
-  const Image *image = tracking->act_plane_track->image;
+  const Image *image = tracking_object->active_plane_track->image;
   return image->type == IMA_TYPE_IMAGE && ELEM(image->source, IMA_SRC_FILE, IMA_SRC_GENERATED);
 }
 
@@ -2323,7 +2323,8 @@ static int update_image_from_plane_marker_exec(bContext *C, wmOperator *UNUSED(o
   SpaceClip *space_clip = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(space_clip);
   MovieTracking *tracking = &clip->tracking;
-  MovieTrackingPlaneTrack *plane_track = tracking->act_plane_track;
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
+  MovieTrackingPlaneTrack *plane_track = tracking_object->active_plane_track;
 
   ImBuf *plane_ibuf = sample_plane_marker_image_for_operator(C);
   if (plane_ibuf == NULL) {
diff --git a/source/blender/editors/space_clip/tracking_ops_plane.c b/source/blender/editors/space_clip/tracking_ops_plane.c
index ed07b3cbcc9..e39260fed97 100644
--- a/source/blender/editors/space_clip/tracking_ops_plane.c
+++ b/source/blender/editors/space_clip/tracking_ops_plane.c
@@ -35,22 +35,22 @@ static int create_plane_track_tracks_exec(bContext *C, wmOperator *op)
   MovieClip *clip = ED_space_clip_get_clip(sc);
   MovieTracking *tracking = &clip->tracking;
   MovieTrackingPlaneTrack *plane_track;
-  ListBase *tracks_base = BKE_tracking_get_active_tracks(tracking);
-  ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   int framenr = ED_space_clip_get_clip_frame_number(sc);
 
-  plane_track = BKE_tracking_plane_track_add(tracking, plane_tracks_base, tracks_base, framenr);
+  plane_track = BKE_tracking_plane_track_add(
+      tracking, &tracking_object->plane_tracks, &tracking_object->tracks, framenr);
 
   if (plane_track == NULL) {
     BKE_report(op->reports, RPT_ERROR, "Need at least 4 selected point tracks to create a plane");
     return OPERATOR_CANCELLED;
   }
 
-  BKE_tracking_tracks_deselect_all(tracks_base);
+  BKE_tracking_tracks_deselect_all(&tracking_object->tracks);
 
   plane_track->flag |= SELECT;
-  clip->tracking.act_track = NULL;
-  clip->tracking.act_plane_track = plane_track;
+  tracking_object->active_track = NULL;
+  tracking_object->active_plane_track = plane_track;
 
   /* Compute homoraphies and apply them on marker's corner, so we've got
    * quite nice motion from the very beginning.
@@ -208,9 +208,10 @@ static int slide_plane_marker_invoke(bContext *C, wmOperator *op, const wmEvent
     SpaceClip *sc = CTX_wm_space_clip(C);
     MovieClip *clip = ED_space_clip_get_clip(sc);
     MovieTracking *tracking = &clip->tracking;
+    MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
 
-    tracking->act_plane_track = slidedata->plane_track;
-    tracking->act_track = NULL;
+    tracking_object->active_plane_track = slidedata->plane_track;
+    tracking_object->active_track = NULL;
 
     op->customdata = slidedata;
 
diff --git a/source/blender/editors/space_clip/tracking_select.c b/source/blender/editors/space_clip/tracking_select.c
index 28e304bfa74..e5689b50f9c 100644
--- a/source/blender/editors/space_clip/tracking_select.c
+++ b/source/blender/editors/space_clip/tracking_select.c
@@ -289,9 +289,7 @@ static int select_exec(bContext *C, wmOperator *op)
   SpaceClip *sc = CTX_wm_space_clip(C);
   MovieClip *clip = ED_space_clip_get_clip(sc);
   MovieTracking *tracking = &clip->tracking;
-  ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
-  ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(tracking);
-  MovieTrackingTrack *act_track = BKE_tracking_track_get_active(tracking);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(tracking);
   const bool extend = RNA_boolean_get(op->ptr, "extend");
   const bool deselect_all = RNA_boolean_get(op->ptr, "deselect_all");
 
@@ -307,7 +305,7 @@ static int select_exec(bContext *C, wmOperator *op)
     if (track != NULL) {
       MovieClip *clip_iter = ED_space_clip_get_clip(sc);
 
-      clip_iter->tracking.act_track = track;
+      tracking_object->active_track = track;
 
       WM_event_add_notifier(C, NC_GEOM | ND_SELECT, NULL);
       DEG_id_tag_update(&clip_iter->id, ID_RECALC_SELECT);
@@ -318,9 +316,10 @@ static int select_exec(bContext *C, wmOperator *op)
 
   float distance_to_track, distance_to_plane_track;
 
-  MovieTrackingTrack *track = find_nearest_track(sc, tracksbase, co, &distance_to_track);
+  MovieTrackingTrack *track = find_nearest_track(
+      sc, &tracking_object->tracks, co, &distance_to_track);
   MovieTrackingPlaneTrack *plane_track = find_nearest_plane_track(
-      sc, plane_tracks_base, co, &distance_to_plane_track);
+      sc, &tracking_object->plane_tracks, co, &distance_to_plane_track);
 
   ClipViewLockState lock_state;
   ED_clip_view_lock_state_store(C, &lock_state);
@@ -346,7 +345,7 @@ static int select_exec(bContext *C, wmOperator *op)
 
   if (track) {
     if (!extend) {
-      ed_tracking_deselect_all_plane_tracks(plane_tracks_base);
+      ed_tracking_deselect_all_plane_tracks(&tracking_object->plane_tracks);
     }
 
     int area = track_mouse_area(C, co, track);
@@ -356,12 +355,12 @@ static int select_exec(bContext *C, wmOperator *op)
     }
 
     if (extend && TRACK_AREA_SELECTED(track, area)) {
-      if (track == act_track) {
+      if (track == tracking_object->active_track) {
         BKE_tracking_track_deselect(track, area);
       }
       else {
-        clip->tracking.act_track = track;
-        clip->tracking.act_plane_track = NULL;
+        tracking_object->active_track = track;
+        tracking_object->active_plane_track = NULL;
       }
     }
     else {
@@ -369,14 +368,14 @@ static int select_exec(bContext *C, wmOperator *op)
         area = TRACK_AREA_ALL;
       }
 
-      BKE_tracking_track_select(tracksbase, track, area, extend);
-      clip->tracking.act_track = track;
-      clip->tracking.act_plane_track = NULL;
+      BKE_tracking_track_select(&tracking_object->tracks, track, area, extend);
+      tracking_object->active_track = track;
+      tracking_object->active_plane_track = NULL;
     }
   }
   else if (plane_track) {
     if (!extend) {
-      ed_tracking_deselect_all_tracks(tracksbase);
+      ed_tracking_deselect_all_tracks(&tracking_object->tracks);
     }
 
     if (PLANE_TRACK_VIEW_SELECTED(plane_track)) {
@@ -388,12 +387,12 @@ static int select_exec(bContext *C, wmOperator *op)
       plane_track->flag |= SELECT;
     }
 
-    clip->tracking.act_track = NULL;
-    clip->tracking.act_plane_track = plane_track;
+    tracking_object->active_track = NULL;
+    tracking_object->active_plane_track = plane_track;
   }
   else if (deselect_all) {
-    ed_tracking_deselect_all_tracks(tracksbase);
-    ed_tracking_deselect_all_plane_tracks(plane_tracks_base);
+    ed_tracking_deselect_all_tracks(&tracking_object->tracks);
+    ed_tracking_deselect_all_plane_tracks(&tracking_object->plane_tracks);
   }
 
   ED_clip_view_lock_state_restore_no_jump(C, &lock_state);
diff --git a/source/blender/makesdna/DNA_tracking_types.h b/source/blender/makesdna/DNA_tracking_types.h
index e252ed73d30..ab792a9befe 100644
--- a/source/blender/makesdna/DNA_tracking_types.h
+++ b/source/blender/makesdna/DNA_tracking_types.h
@@ -350,10 +350,14 @@ typedef struct MovieTrackingObject {
   /** Scale of object solution in camera space. */
   float scale;
 
-  /** List of tracks use to tracking this object. */
+  /** Lists of point and plane tracks use to tracking this object. */
   ListBase tracks;
-  /** List of plane tracks used by this object. */
   ListBase plane_tracks;
+
+  /** Active point and plane tracks. */
+  MovieTrackingTrack *active_track;
+  MovieTrackingPlaneTrack *active_plane_track;
+
   /** Reconstruction data for this object. */
   MovieTrackingReconstruction reconstruction;
 
@@ -422,18 +426,22 @@ typedef struct MovieTracking {
   MovieTrackingSettings settings;
   /** Camera intrinsics. */
   MovieTrackingCamera camera;
-  /** List of tracks used for camera object. */
-  ListBase tracks;
-  /** List of plane tracks used by camera object. */
-  ListBase plane_tracks;
-  /** Reconstruction data for camera object. */
-  MovieTrackingReconstruction reconstruction;
+  /** Lists of point and plane tracks used for camera object.
+   * NOTE: Only left for the versioning purposes. */
+  ListBase tracks_legacy;
+  ListBase plane_tracks_legacy;
+
+  /** Reconstruction data for camera object.
+   * NOTE: Only left for the versioning purposes. */
+  MovieTrackingReconstruction reconstruction_legacy;
+
   /** Stabilization data. */
   MovieTrackingStabilization stabilization;
-  /** Active track. */
-  MovieTrackingTrack *act_track;
-  /** Active plane track. */
-  MovieTrackingPlaneTrack *act_plane_track;
+
+  /** Active point and plane tracks.
+   * NOTE: Only left for the versioning purposes. */
+  MovieTrackingTrack *act_track_legacy;
+  MovieTrackingPlaneTrack *act_plane_track_legacy;
 
   ListBase objects;
   /** Index of active object and total number of objects. */
diff --git a/source/blender/makesdna/intern/dna_rename_defs.h b/source/blender/makesdna/intern/dna_rename_defs.h
index afc907b7780..615e9740c9f 100644
--- a/source/blender/makesdna/intern/dna_rename_defs.h
+++ b/source/blender/makesdna/intern/dna_rename_defs.h
@@ -90,6 +90,11 @@ DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totcagevert, cage_verts_num)
 DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totinfluence, influences_num)
 DNA_STRUCT_RENAME_ELEM(MeshDeformModifierData, totvert, verts_num)
 DNA_STRUCT_RENAME_ELEM(MovieClip, name, filepath)
+DNA_STRUCT_RENAME_ELEM(MovieTracking, tracks, tracks_legacy)
+DNA_STRUCT_RENAME_ELEM(MovieTracking, plane_tracks, plane_tracks_legacy)
+DNA_STRUCT_RENAME_ELEM(MovieTracking, reconstruction, reconstruction_legacy)
+DNA_STRUCT_RENAME_ELEM(MovieTracking, act_track, act_track_legacy)
+DNA_STRUCT_RENAME_ELEM(MovieTracking, act_plane_track, act_plane_track_legacy)
 DNA_STRUCT_RENAME_ELEM(NodeCryptomatte, num_inputs, inputs_num)
 DNA_STRUCT_RENAME_ELEM(Object, col, color)
 DNA_STRUCT_RENAME_ELEM(Object, dup_group, instance_collection)
diff --git a/source/blender/makesrna/intern/rna_tracking.c b/source/blender/makesrna/intern/rna_tracking.c
index 44df0db9ade..2de639e919a 100644
--- a/source/blender/makesrna/intern/rna_tracking.c
+++ b/source/blender/makesrna/intern/rna_tracking.c
@@ -87,15 +87,17 @@ static char *rna_trackingTrack_path(const PointerRNA *ptr)
 static void rna_trackingTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
 
-  rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
+  rna_iterator_listbase_begin(iter, &tracking_camera_object->tracks, NULL);
 }
 
 static void rna_trackingPlaneTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
 
-  rna_iterator_listbase_begin(iter, &clip->tracking.plane_tracks, NULL);
+  rna_iterator_listbase_begin(iter, &tracking_camera_object->plane_tracks, NULL);
 }
 
 static void rna_trackingObjects_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
@@ -143,14 +145,15 @@ static void rna_tracking_active_track_set(PointerRNA *ptr,
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
   MovieTrackingTrack *track = (MovieTrackingTrack *)value.data;
-  ListBase *tracksbase = BKE_tracking_get_active_tracks(&clip->tracking);
-  int index = BLI_findindex(tracksbase, track);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
+  int index = BLI_findindex(&tracking_object->tracks, track);
 
   if (index != -1) {
-    clip->tracking.act_track = track;
+    tracking_object->active_track = track;
   }
   else {
-    clip->tracking.act_track = NULL;
+    /* TODO(sergey): Raise an error. */
+    tracking_object->active_track = NULL;
   }
 }
 
@@ -168,14 +171,15 @@ static void rna_tracking_active_plane_track_set(PointerRNA *ptr,
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
   MovieTrackingPlaneTrack *plane_track = (MovieTrackingPlaneTrack *)value.data;
-  ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
-  int index = BLI_findindex(plane_tracks_base, plane_track);
+  MovieTrackingObject *tracking_object = BKE_tracking_object_get_active(&clip->tracking);
+  int index = BLI_findindex(&tracking_object->plane_tracks, plane_track);
 
   if (index != -1) {
-    clip->tracking.act_plane_track = plane_track;
+    tracking_object->active_plane_track = plane_track;
   }
   else {
-    clip->tracking.act_plane_track = NULL;
+    /* TODO(sergey): Raise an error. */
+    tracking_object->active_plane_track = NULL;
   }
 }
 
@@ -354,7 +358,8 @@ static int rna_track_2d_stabilization_rotation(CollectionPropertyIterator *UNUSE
 static void rna_tracking_stabTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
-  rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization);
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
+  rna_iterator_listbase_begin(iter, &tracking_camera_object->tracks, rna_track_2d_stabilization);
 }
 
 static int rna_tracking_stabTracks_active_index_get(PointerRNA *ptr)
@@ -381,7 +386,9 @@ static void rna_tracking_stabTracks_active_index_range(
 static void rna_tracking_stabRotTracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
   MovieClip *clip = (MovieClip *)ptr->owner_id;
-  rna_iterator_listbase_begin(iter, &clip->tracking.tracks, rna_track_2d_stabilization_rotation);
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
+  rna_iterator_listbase_begin(
+      iter, &tracking_camera_object->tracks, rna_track_2d_stabilization_rotation);
 }
 
 static int rna_tracking_stabRotTracks_active_index_get(PointerRNA *ptr)
@@ -433,46 +440,21 @@ static void rna_tracking_resetIntrinsics(Main *UNUSED(bmain),
 static void rna_trackingObject_tracks_begin(CollectionPropertyIterator *iter, PointerRNA *ptr)
 {
   MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
-
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
-    MovieClip *clip = (MovieClip *)ptr->owner_id;
-
-    rna_iterator_listbase_begin(iter, &clip->tracking.tracks, NULL);
-  }
-  else {
-    rna_iterator_listbase_begin(iter, &object->tracks, NULL);
-  }
+  rna_iterator_listbase_begin(iter, &object->tracks, NULL);
 }
 
 static void rna_trackingObject_plane_tracks_begin(CollectionPropertyIterator *iter,
                                                   PointerRNA *ptr)
 {
   MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
-
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
-    MovieClip *clip = (MovieClip *)ptr->owner_id;
-
-    rna_iterator_listbase_begin(iter, &clip->tracking.plane_tracks, NULL);
-  }
-  else {
-    rna_iterator_listbase_begin(iter, &object->plane_tracks, NULL);
-  }
+  rna_iterator_listbase_begin(iter, &object->plane_tracks, NULL);
 }
 
 static PointerRNA rna_trackingObject_reconstruction_get(PointerRNA *ptr)
 {
   MovieTrackingObject *object = (MovieTrackingObject *)ptr->data;
-
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
-    MovieClip *clip = (MovieClip *)ptr->owner_id;
-
-    return rna_pointer_inherit_refine(
-        ptr, &RNA_MovieTrackingReconstruction, &clip->tracking.reconstruction);
-  }
-  else {
-    return rna_pointer_inherit_refine(
-        ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
-  }
+  return rna_pointer_inherit_refine(
+      ptr, &RNA_MovieTrackingReconstruction, &object->reconstruction);
 }
 
 static PointerRNA rna_tracking_active_object_get(PointerRNA *ptr)
@@ -621,9 +603,11 @@ static MovieTrackingTrack *rna_trackingTracks_new(ID *id,
                                                   int frame)
 {
   MovieClip *clip = (MovieClip *)id;
+  MovieTrackingObject *tracking_camera_object = BKE_tracking_object_get_camera(&clip->tracking);
+
   MovieTrackingTrack *track;
 
-  track = add_track_to_base(clip, tracking, &tracking->tracks, name, frame);
+  track = add_track_to_base(clip, tracking, &tracking_camera_object->tracks, name, frame);
 
   WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, clip);
 
@@ -639,10 +623,6 @@ static MovieTrackingTrack *rna_trackingObject_tracks_new(ID *id,
   ListBase *tracksbase = &object->tracks;
   MovieTrackingTrack *track;
 
-  if (object->flag & TRACKING_OBJECT_CAMERA) {
-    tracksbase = &clip->tracking.tracks;
-  }
-
   track = add_track_to_base(clip, &clip->tracking, tracksbase, name, frame);
 
   WM_main_add_notifier(NC_MOVIECLIP | NA_EDITED, NULL);
@@ -772,12 +752,7 @@ static MovieTrackingObject *find_object_for_reconstruction(
   MovieTrackingObject *object;
 
   for (object = tracking->objects.first; object; object = object->next) {
-    if (object->flag & TRACKING_OBJECT_CAMERA) {
-      if (&tracking->reconstruction == reconstruction) {
-        return object;
-      }
-    }
-    else if (&object->reconstruction == reconstruction) {
+    if (&object->reconstruction == reconstruction) {
       return object;
     }
   }
@@ -2539,6 +2514,7 @@ static void rna_def_tracking(BlenderRNA *brna)
 
   /* reconstruction */
   prop = RNA_def_property(srna, "reconstruction", PROP_POINTER, PROP_NONE);
+  RNA_def_property_pointer_sdna(prop, NULL, "reconstruction_legacy");
   RNA_def_property_struct_type(prop, "MovieTrackingReconstruction");
 
   /* objects */