Tracking: Refactor autotrack tracking implementation

The idea is to avoid any synchronization needed in the worker threads
and make them to operate on a local data. From implementation detail
this is achieved by keeping track of "wavefront" of markers which are
to be tracked and the tracking result. Insertion of results to the
AutoTrack context happens from main thread, which avoids need in the
lock when accessing AutoTrack.

This change makes tracking of many (300+) about 10% faster on the
Xeon) CPU E5-2699 v4. More speedup will be gained by minimizing
threading overhead in the frame cache.

Another important aspect of this change is that it fixes non-thread
safe access which was often causing crashes. Quite surprising the
crash was never reported.
This commit is contained in:
Sergey Sharybin 2020-11-30 18:13:07 +01:00
parent 4c92fb6715
commit 29401d38d1
1 changed files with 497 additions and 255 deletions

View File

@ -41,39 +41,65 @@
#include "libmv-capi.h"
#include "tracking_private.h"
typedef struct AutoTrackOptions {
int clip_index; /** Index of the clip this track belongs to. */
int track_index; /* Index of the track in AutoTrack tracks structure. */
MovieTrackingTrack *track; /* Pointer to an original track/ */
libmv_TrackRegionOptions track_region_options; /* Options for the region tracker. */
typedef struct AutoTrackClip {
MovieClip *clip;
/* Define which frame is used for reference marker. */
eTrackFrameMatch frame_match;
/* Dimensions of movie frame, in pixels.
*
* NOTE: All frames within a clip are expected to have match3ed dimensions. */
int width, height;
} AutoTrackClip;
/* TODO(sergey): A bit awkward to keep it in here, only used to
* place a disabled marker once the tracking fails,
* Either find a clearer way to do it or call it track context
* or state, not options.
*/
bool is_failed;
int failed_frame;
} AutoTrackOptions;
typedef struct AutoTrackTrack {
/* Index of a clip from `AutoTrackContext::autotrack_clips` this track belongs to. */
int clip_index;
MovieTrackingTrack *track;
/* Options for the region tracker. */
libmv_TrackRegionOptions track_region_options;
/* Denotes whether this track will be tracked.
* Is usually initialized based on track's selection. Non-trackable tracks are still added to the
* context to provide AutoTrack all knowledge about what is going on in the scene. */
bool is_trackable;
} AutoTrackTrack;
typedef struct AutoTrackMarker {
libmv_Marker libmv_marker;
} AutoTrackMarker;
/* Result of tracking step for a single marker.
*
* On success both marker and result are fully initialized to the position on the new frame.
*
* On failure marker's frame number is initialized to frame number where it was attempted to be
* tracked to. The position and other fields of tracked marker are the same as the input. */
typedef struct AutoTrackTrackingResult {
struct AutoTrackTrackingResult *next, *prev;
bool success;
libmv_Marker libmv_marker;
libmv_TrackRegionResult libmv_result;
} AutoTrackTrackingResult;
typedef struct AutoTrackContext {
/* --------------------------------------------------------------------
* Invariant part.
* Stays unchanged during the tracking process.
* If not the initialization process, all the fields here should be treated as `const`.
*/
/* Frame at which tracking process started.
* NOTE: Measured in scene time frames, */
int start_scene_frame;
/* Scene frame number from which tracker will perform the trackign step.
* The direction of the step is denoted by `is_backwards`. */
int current_scene_frame;
/* True when tracking backwards (from higher frame number to lower frame number.) */
bool is_backwards;
/* Movie clips used during the trackign process. */
int num_clips;
MovieClip *clips[MAX_ACCESSOR_CLIP];
AutoTrackClip autotrack_clips[MAX_ACCESSOR_CLIP];
/* Tracks for which the context has been created for.
* This is a flat array of all tracks coming from all clips, regardless of whether track is
@ -82,35 +108,41 @@ typedef struct AutoTrackContext {
*
* Indexed by AutoTrackOptions::track_index. */
int num_all_tracks;
MovieTrackingTrack **all_tracks;
/* Dimensions of movie frame, in pixels.
*
* NOTE: All clips and frames within a clip are expected to have match3ed dimensions.
*
* TODO(sergey): Make it more flexible to fully support multiple-clip tracking. Could either be
* stored as a `pair<MovieClip, Dimensions>` or even be replaced with actual frame size access
* to support variadic frame dimensions. */
int frame_width, frame_height;
AutoTrackTrack *all_autotrack_tracks;
/* Accessor for images of clip. Used by the autotrack context. */
TrackingImageAccessor *image_accessor;
/* --------------------------------------------------------------------
* Variant part.
* Denotes tracing state and tracking result.
*/
/* Auto-track context.
*
* NOTE: Is accessed from multiple threads at once. */
struct libmv_AutoTrack *autotrack;
int num_track_options;
AutoTrackOptions *track_options; /* Per-tracking track options. */
/* Markers from the current frame which will be tracked to the next frame upon the tracking
* context step.
*
* NOTE: This array is re-used across tracking steps, which might make it appear that the array
* is over-allocated when some tracks has failed to track. */
int num_autotrack_markers;
AutoTrackMarker *autotrack_markers;
/* Tracking results which are to be synchronized from the AutoTrack context to the Blender's
* DNA to make the results visible for users. */
ListBase results_to_sync;
int synchronized_scene_frame;
int sync_frame;
bool first_sync;
SpinLock spin_lock;
bool step_ok;
} AutoTrackContext;
/* -------------------------------------------------------------------- */
/** \name Marker coordinate system conversion.
* \{ */
static void normalized_to_libmv_frame(const float normalized[2],
const int frame_dimensions[2],
float result[2])
@ -145,8 +177,14 @@ static void libmv_frame_to_normalized_relative(const float frame_coord[2],
result[1] = (frame_coord[1] - origin[1]) / frame_dimensions[1];
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Coversion of markers between Blender's DNA and Libmv.
* \{ */
static void dna_marker_to_libmv_marker(/*const*/ MovieTrackingTrack *track,
/*const*/ MovieTrackingMarker *marker,
const MovieTrackingMarker *marker,
int clip,
int track_index,
int frame_width,
@ -171,7 +209,9 @@ static void dna_marker_to_libmv_marker(/*const*/ MovieTrackingTrack *track,
normalized_relative_to_libmv_frame(
marker->search_max, marker->pos, frame_dimensions, libmv_marker->search_region_max);
/* TODO(sergey): All the markers does have 1.0 weight. */
/* NOTE: All the markers does have 1.0 weight.
* Might support in the future, but will require more elaborated process which will involve
* F-Curve evaluation. */
libmv_marker->weight = 1.0f;
if (marker->flag & MARKER_TRACKED) {
@ -184,13 +224,11 @@ static void dna_marker_to_libmv_marker(/*const*/ MovieTrackingTrack *track,
libmv_marker->model_type = LIBMV_MARKER_MODEL_TYPE_POINT;
libmv_marker->model_id = 0;
/* TODO(sergey): We currently don't support reference marker from
* different clip.
*/
/* NOTE: We currently don't support reference marker from different clip. */
libmv_marker->reference_clip = clip;
if (track->pattern_match == TRACK_MATCH_KEYFRAME) {
MovieTrackingMarker *keyframe_marker = tracking_get_keyframed_marker(
const MovieTrackingMarker *keyframe_marker = tracking_get_keyframed_marker(
track, marker->framenr, backwards);
libmv_marker->reference_frame = keyframe_marker->framenr;
}
@ -235,20 +273,17 @@ static void libmv_marker_to_dna_marker(libmv_Marker *libmv_marker,
}
}
static bool check_track_trackable(const MovieClip *clip,
MovieTrackingTrack *track,
const MovieClipUser *user)
{
if (TRACK_SELECTED(track) && (track->flag & (TRACK_LOCKED | TRACK_HIDDEN)) == 0) {
int frame = BKE_movieclip_remap_scene_to_clip_frame(clip, user->framenr);
const MovieTrackingMarker *marker = BKE_tracking_marker_get(track, frame);
return (marker->flag & MARKER_DISABLED) == 0;
}
return false;
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name General helpers.
*
* TODO(sergey): Should be moved to tracking_util.c
*
* \{ */
/* Returns false if marker crossed margin area from frame bounds. */
static bool tracking_check_marker_margin(libmv_Marker *libmv_marker,
static bool tracking_check_marker_margin(const libmv_Marker *libmv_marker,
int margin,
int frame_width,
int frame_height)
@ -277,91 +312,234 @@ static bool tracking_check_marker_margin(libmv_Marker *libmv_marker,
return true;
}
/* Provide Libmv side of auto track all information about given tracks. */
static void fill_autotrack_tracks(const int frame_width,
const int frame_height,
const ListBase *tracksbase,
const bool backwards,
struct libmv_AutoTrack *autotrack)
/** \} */
/* -------------------------------------------------------------------- */
/** \name Autotrack context initialization.
* \{ */
static bool autotrack_is_marker_usable(const MovieTrackingMarker *marker)
{
/* Count number of markers to be put to a context. */
size_t num_trackable_markers = 0;
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
for (int i = 0; i < track->markersnr; i++) {
const MovieTrackingMarker *marker = track->markers + i;
if ((marker->flag & MARKER_DISABLED) == 0) {
num_trackable_markers++;
if ((marker->flag & MARKER_DISABLED)) {
return false;
}
return true;
}
static bool autotrack_is_track_trackable(const AutoTrackContext *context,
const AutoTrackTrack *autotrack_track)
{
/*const*/ MovieTrackingTrack *track = autotrack_track->track;
if (TRACK_SELECTED(track) && (track->flag & (TRACK_LOCKED | TRACK_HIDDEN)) == 0) {
const AutoTrackClip *autotrack_clip = &context->autotrack_clips[autotrack_track->clip_index];
MovieClip *clip = autotrack_clip->clip;
const int clip_frame_number = BKE_movieclip_remap_scene_to_clip_frame(
clip, context->start_scene_frame);
const MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame_number);
return autotrack_is_marker_usable(marker);
}
return false;
}
static void autotrack_context_init_clips(AutoTrackContext *context,
MovieClip *clip,
MovieClipUser *user)
{
/* NOTE: Currently only tracking within a single clip. */
context->num_clips = 1;
context->autotrack_clips[0].clip = clip;
BKE_movieclip_get_size(
clip, user, &context->autotrack_clips[0].width, &context->autotrack_clips[0].height);
}
/* Initialize flat list of tracks for quick index-based access for the specified clip.
* All the tracks from this clip are added at the end of the array of already-collected tracks.
*
* NOTE: Clips should be initialized first. */
static void autotrack_context_init_tracks_for_clip(AutoTrackContext *context, int clip_index)
{
BLI_assert(clip_index >= 0);
BLI_assert(clip_index < context->num_clips);
const AutoTrackClip *autotrack_clip = &context->autotrack_clips[clip_index];
MovieClip *clip = autotrack_clip->clip;
MovieTracking *tracking = &clip->tracking;
ListBase *tracks_base = BKE_tracking_get_active_tracks(tracking);
const int num_clip_tracks = BLI_listbase_count(tracks_base);
if (num_clip_tracks == 0) {
return;
}
context->all_autotrack_tracks = MEM_reallocN(context->all_autotrack_tracks,
(context->num_all_tracks + num_clip_tracks) *
sizeof(AutoTrackTrack));
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracks_base) {
AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[context->num_all_tracks++];
autotrack_track->clip_index = clip_index;
autotrack_track->track = track;
autotrack_track->is_trackable = autotrack_is_track_trackable(context, autotrack_track);
tracking_configure_tracker(track, NULL, &autotrack_track->track_region_options);
}
}
/* Initialize flat list of tracks for quick index-based access for all clips used for tracking.
*
* NOTE: Clips should be initialized first. */
static void autotrack_context_init_tracks(AutoTrackContext *context)
{
BLI_assert(context->num_clips >= 1);
for (int clip_index = 0; clip_index < context->num_clips; ++clip_index) {
autotrack_context_init_tracks_for_clip(context, clip_index);
}
}
/* NOTE: Clips should be initialized first. */
static void autotrack_context_init_image_accessor(AutoTrackContext *context)
{
BLI_assert(context->num_clips >= 1);
/* Planarize arrays of clips and tracks, storing pointers to their base "objects".
* This allows image accessor to be independent, but adds some overhead here. Could be solved
* by either more strongly coupling accessor API with the AutoTrack, or by giving some functors
* to the accessor to access clip/track from their indices. */
MovieClip *clips[MAX_ACCESSOR_CLIP];
for (int i = 0; i < context->num_clips; ++i) {
clips[i] = context->autotrack_clips[i].clip;
}
MovieTrackingTrack **tracks = MEM_malloc_arrayN(
context->num_all_tracks, sizeof(MovieTrackingTrack *), "image accessor init tracks");
for (int i = 0; i < context->num_all_tracks; ++i) {
tracks[i] = context->all_autotrack_tracks[i].track;
}
context->image_accessor = tracking_image_accessor_new(clips, 1, tracks, context->num_all_tracks);
MEM_freeN(tracks);
}
/* Count markers which are usable to be passed to the AutoTrack context. */
static size_t autotrack_count_all_usable_markers(AutoTrackContext *context)
{
size_t num_usable_markers = 0;
for (int track_index = 0; track_index < context->num_all_tracks; ++track_index) {
const MovieTrackingTrack *track = context->all_autotrack_tracks[track_index].track;
for (int marker_index = 0; marker_index < track->markersnr; ++marker_index) {
const MovieTrackingMarker *marker = &track->markers[marker_index];
if (!autotrack_is_marker_usable(marker)) {
continue;
}
num_usable_markers++;
}
}
/* Early output if we don't have any markers. */
return num_usable_markers;
}
static int autotrack_count_trackable_markers(AutoTrackContext *context)
{
int num_trackable_markers = 0;
for (int track_index = 0; track_index < context->num_all_tracks; ++track_index) {
const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
if (!autotrack_track->is_trackable) {
continue;
}
num_trackable_markers++;
}
return num_trackable_markers;
}
/* Provide Libmv side of auto track all information about given tracks.
* Information from all clips is passed to the auto tracker.
*
* NOTE: Clips and all tracks are to be initialized before calling this. */
static void autotrack_context_init_autotrack(AutoTrackContext *context)
{
context->autotrack = libmv_autoTrackNew(context->image_accessor->libmv_accessor);
/* Count number of markers to be put to a context. */
const size_t num_trackable_markers = autotrack_count_all_usable_markers(context);
if (num_trackable_markers == 0) {
return;
}
/* Allocate memory for all the markers. */
libmv_Marker *libmv_markers = MEM_mallocN(sizeof(libmv_Marker) * num_trackable_markers,
"libmv markers array");
libmv_Marker *libmv_markers = MEM_malloc_arrayN(
sizeof(libmv_Marker), num_trackable_markers, "libmv markers array");
/* Fill in markers array. */
int track_index = 0, num_filled_libmv_markers = 0;
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
for (int i = 0; i < track->markersnr; i++) {
MovieTrackingMarker *marker = track->markers + i;
if ((marker->flag & MARKER_DISABLED) != 0) {
int num_filled_libmv_markers = 0;
for (int track_index = 0; track_index < context->num_all_tracks; ++track_index) {
const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
/*const*/ MovieTrackingTrack *track = autotrack_track->track;
for (int marker_index = 0; marker_index < track->markersnr; ++marker_index) {
/*const*/ MovieTrackingMarker *marker = &track->markers[marker_index];
if (!autotrack_is_marker_usable(marker)) {
continue;
}
const AutoTrackClip *autotrack_clip = &context->autotrack_clips[autotrack_track->clip_index];
dna_marker_to_libmv_marker(track,
marker,
0,
autotrack_track->clip_index,
track_index,
frame_width,
frame_height,
backwards,
autotrack_clip->width,
autotrack_clip->height,
context->is_backwards,
&libmv_markers[num_filled_libmv_markers++]);
}
/* Put all markers to autotrack at once. */
track_index++;
}
/* Add all markers to autotrack. */
libmv_autoTrackSetMarkers(autotrack, libmv_markers, num_trackable_markers);
libmv_autoTrackSetMarkers(context->autotrack, libmv_markers, num_trackable_markers);
/* Free temporary memory. */
MEM_freeN(libmv_markers);
}
static void create_per_track_tracking_options(const MovieClip *clip,
const MovieClipUser *user,
const ListBase *tracksbase,
AutoTrackContext *context)
static void autotrack_context_init_markers(AutoTrackContext *context)
{
/* Count number of trackable tracks. */
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
if (check_track_trackable(clip, track, user)) {
context->num_track_options++;
}
context->num_autotrack_markers = autotrack_count_trackable_markers(context);
if (context->num_autotrack_markers == 0) {
return;
}
/* Allocate required memory. */
context->track_options = MEM_callocN(sizeof(AutoTrackOptions) * context->num_track_options,
"auto track options");
/* Fill in all the settings. */
int i = 0, track_index = 0;
LISTBASE_FOREACH (MovieTrackingTrack *, track, tracksbase) {
context->all_tracks[track_index] = track;
if (!check_track_trackable(clip, track, user)) {
track_index++;
/* Allocate required memory. */
context->autotrack_markers = MEM_calloc_arrayN(
sizeof(AutoTrackMarker), context->num_autotrack_markers, "auto track options");
/* Fill in all the markers. */
int autotrack_marker_index = 0;
for (int track_index = 0; track_index < context->num_all_tracks; ++track_index) {
const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
if (!autotrack_track->is_trackable) {
continue;
}
AutoTrackOptions *track_options = &context->track_options[i++];
const AutoTrackClip *autotrack_clip = &context->autotrack_clips[autotrack_track->clip_index];
MovieClip *clip = autotrack_clip->clip;
const int clip_frame_number = BKE_movieclip_remap_scene_to_clip_frame(
clip, context->start_scene_frame);
/* TODO(sergey): Single clip only for now. */
track_options->clip_index = 0;
track_options->track_index = track_index;
track_options->track = track;
track_options->frame_match = track->pattern_match;
/*const*/ MovieTrackingTrack *track = context->all_autotrack_tracks[track_index].track;
const MovieTrackingMarker *marker = BKE_tracking_marker_get(track, clip_frame_number);
tracking_configure_tracker(track, NULL, &track_options->track_region_options);
track_index++;
AutoTrackMarker *autotrack_marker = &context->autotrack_markers[autotrack_marker_index++];
dna_marker_to_libmv_marker(track,
marker,
autotrack_track->clip_index,
track_index,
autotrack_clip->width,
autotrack_clip->height,
context->is_backwards,
&autotrack_marker->libmv_marker);
}
}
@ -370,198 +548,247 @@ AutoTrackContext *BKE_autotrack_context_new(MovieClip *clip,
const bool is_backwards)
{
AutoTrackContext *context = MEM_callocN(sizeof(AutoTrackContext), "autotrack context");
MovieTracking *tracking = &clip->tracking;
ListBase *tracksbase = BKE_tracking_get_active_tracks(tracking);
int frame_width, frame_height;
/* get size of frame to convert normalized coordinates to a picture ones. */
BKE_movieclip_get_size(clip, user, &frame_width, &frame_height);
/* TODO(sergey): Currently using only a single clip. */
context->clips[0] = clip;
context->num_clips = 1;
context->current_scene_frame = user->framenr;
context->frame_width = frame_width;
context->frame_height = frame_height;
context->is_backwards = is_backwards;
context->start_scene_frame = user->framenr;
context->sync_frame = user->framenr;
context->first_sync = true;
context->is_backwards = is_backwards;
context->synchronized_scene_frame = context->start_scene_frame;
autotrack_context_init_clips(context, clip, user);
autotrack_context_init_tracks(context);
autotrack_context_init_image_accessor(context);
autotrack_context_init_autotrack(context);
autotrack_context_init_markers(context);
BLI_spin_init(&context->spin_lock);
context->num_all_tracks = BLI_listbase_count(tracksbase);
context->all_tracks = MEM_callocN(sizeof(MovieTrackingTrack *) * context->num_all_tracks,
"auto track pointers");
/* Create per-track tracking options. */
create_per_track_tracking_options(clip, user, tracksbase, context);
/* Initialize image accessor. */
context->image_accessor = tracking_image_accessor_new(
context->clips, 1, context->all_tracks, context->num_all_tracks);
/* Initialize auto track context and provide all information about currently
* tracked markers.
*/
context->autotrack = libmv_autoTrackNew(context->image_accessor->libmv_accessor);
fill_autotrack_tracks(frame_width, frame_height, tracksbase, is_backwards, context->autotrack);
return context;
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Threaded context step (tracking process).
* \{ */
/* NOTE: This is a TLS in a sense that this struct is never accessed from multiple threads, and
* that threads are re-using the struct as much as possible. */
typedef struct AutoTrackTLS {
ListBase results; /* Elements of `AutoTrackTrackingResult`. */
} AutoTrackTLS;
static void autotrack_context_step_cb(void *__restrict userdata,
const int track,
const TaskParallelTLS *__restrict UNUSED(tls))
const int marker_index,
const TaskParallelTLS *__restrict tls)
{
AutoTrackContext *context = userdata;
AutoTrackTLS *autotrack_tls = (AutoTrackTLS *)tls->userdata_chunk;
const AutoTrackMarker *autotrack_marker = &context->autotrack_markers[marker_index];
const libmv_Marker *libmv_current_marker = &autotrack_marker->libmv_marker;
const int frame_delta = context->is_backwards ? -1 : 1;
const int clip_index = libmv_current_marker->clip;
const int track_index = libmv_current_marker->track;
AutoTrackOptions *track_options = &context->track_options[track];
if (track_options->is_failed) {
return;
}
const AutoTrackClip *autotrack_clip = &context->autotrack_clips[clip_index];
const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
const MovieTrackingTrack *track = autotrack_track->track;
const int track_index = track_options->track_index;
const int clip_index = track_options->clip_index;
libmv_Marker libmv_current_marker, libmv_reference_marker, libmv_tracked_marker;
libmv_TrackRegionResult libmv_result;
MovieClip *clip = context->clips[clip_index];
const int frame = BKE_movieclip_remap_scene_to_clip_frame(clip, context->current_scene_frame);
BLI_spin_lock(&context->spin_lock);
const bool has_marker = libmv_autoTrackGetMarker(
context->autotrack, clip_index, frame, track_index, &libmv_current_marker);
BLI_spin_unlock(&context->spin_lock);
/* Check whether we've got marker to sync with. */
if (!has_marker) {
return;
}
/* Check whether marker is going outside of allowed frame margin. */
if (!tracking_check_marker_margin(&libmv_current_marker,
track_options->track->margin,
context->frame_width,
context->frame_height)) {
if (!tracking_check_marker_margin(
libmv_current_marker, track->margin, autotrack_clip->width, autotrack_clip->height)) {
return;
}
libmv_tracked_marker = libmv_current_marker;
libmv_tracked_marker.frame = frame + frame_delta;
const int new_marker_frame = libmv_current_marker->frame + frame_delta;
AutoTrackTrackingResult *autotrack_result = MEM_mallocN(sizeof(AutoTrackTrackingResult),
"autotrack result");
autotrack_result->libmv_marker = *libmv_current_marker;
autotrack_result->libmv_marker.frame = new_marker_frame;
/* Update reference frame. */
if (track_options->frame_match == TRACK_MATCH_KEYFRAME) {
libmv_tracked_marker.reference_frame = libmv_current_marker.reference_frame;
libmv_Marker libmv_reference_marker;
if (track->pattern_match == TRACK_MATCH_KEYFRAME) {
autotrack_result->libmv_marker.reference_frame = libmv_current_marker->reference_frame;
libmv_autoTrackGetMarker(context->autotrack,
track_options->clip_index,
libmv_tracked_marker.reference_frame,
track_options->track_index,
clip_index,
autotrack_result->libmv_marker.reference_frame,
track_index,
&libmv_reference_marker);
}
else {
BLI_assert(track_options->frame_match == TRACK_MATCH_PREVIOS_FRAME);
libmv_tracked_marker.reference_frame = frame;
libmv_reference_marker = libmv_current_marker;
}
/* Perform actual tracking. */
if (libmv_autoTrackMarker(context->autotrack,
&track_options->track_region_options,
&libmv_tracked_marker,
&libmv_result)) {
BLI_spin_lock(&context->spin_lock);
libmv_autoTrackAddMarker(context->autotrack, &libmv_tracked_marker);
BLI_spin_unlock(&context->spin_lock);
}
else {
track_options->is_failed = true;
track_options->failed_frame = frame + frame_delta;
BLI_assert(track->pattern_match == TRACK_MATCH_PREVIOS_FRAME);
autotrack_result->libmv_marker.reference_frame = libmv_current_marker->frame;
libmv_reference_marker = *libmv_current_marker;
}
/* Note: Atomic is probably not actually needed here, I doubt we could get
* any other result than a true bool anyway.
* But for sake of consistency, and since it costs nothing...
*/
atomic_fetch_and_or_uint8((uint8_t *)&context->step_ok, true);
/* Perform actual tracking. */
autotrack_result->success = libmv_autoTrackMarker(context->autotrack,
&autotrack_track->track_region_options,
&autotrack_result->libmv_marker,
&autotrack_result->libmv_result);
/* If tracking failed restore initial position.
* This is how Blender side is currently expecting failed track to be handled. Without this the
* marker is left in an arbitrary position which did not provide good correlation. */
if (!autotrack_result->success) {
autotrack_result->libmv_marker = *libmv_current_marker;
autotrack_result->libmv_marker.frame = new_marker_frame;
}
BLI_addtail(&autotrack_tls->results, autotrack_result);
}
static void autotrack_context_reduce(const void *__restrict UNUSED(userdata),
void *__restrict chunk_join,
void *__restrict chunk)
{
AutoTrackTLS *autotrack_tls = (AutoTrackTLS *)chunk;
if (BLI_listbase_is_empty(&autotrack_tls->results)) {
/* Nothing to be joined from. */
return;
}
AutoTrackTLS *autotrack_tls_join = (AutoTrackTLS *)chunk_join;
BLI_movelisttolist(&autotrack_tls_join->results, &autotrack_tls->results);
}
bool BKE_autotrack_context_step(AutoTrackContext *context)
{
const int frame_delta = context->is_backwards ? -1 : 1;
context->step_ok = false;
if (context->num_autotrack_markers == 0) {
return false;
}
AutoTrackTLS tls;
BLI_listbase_clear(&tls.results);
TaskParallelSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (context->num_track_options > 1);
BLI_task_parallel_range(
0, context->num_track_options, context, autotrack_context_step_cb, &settings);
settings.use_threading = (context->num_autotrack_markers > 1);
settings.userdata_chunk = &tls;
settings.userdata_chunk_size = sizeof(AutoTrackTLS);
settings.func_reduce = autotrack_context_reduce;
BLI_task_parallel_range(
0, context->num_autotrack_markers, context, autotrack_context_step_cb, &settings);
/* Prepare next tracking step by updating the AutoTrack context with new markers and moving
* tracked markers as an input for the next iteration. */
context->num_autotrack_markers = 0;
LISTBASE_FOREACH (AutoTrackTrackingResult *, autotrack_result, &tls.results) {
if (!autotrack_result->success) {
continue;
}
/* Insert tracking results to the AutoTrack context to make them usable for the next frame
* tracking iteration. */
libmv_autoTrackAddMarker(context->autotrack, &autotrack_result->libmv_marker);
/* Update the list of markers which will be tracked on the next iteration. */
context->autotrack_markers[context->num_autotrack_markers++].libmv_marker =
autotrack_result->libmv_marker;
}
/* Advance the frame. */
BLI_spin_lock(&context->spin_lock);
context->current_scene_frame += frame_delta;
BLI_movelisttolist(&context->results_to_sync, &tls.results);
BLI_spin_unlock(&context->spin_lock);
return context->step_ok;
return true;
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Context data synchronization.
*
* Used to copy trackign result to Blender side, while the trackign is still happening in its
* thread.
*
* \{ */
void BKE_autotrack_context_sync(AutoTrackContext *context)
{
int newframe, frame_delta = context->is_backwards ? -1 : 1;
const int frame_delta = context->is_backwards ? -1 : 1;
BLI_spin_lock(&context->spin_lock);
newframe = context->current_scene_frame;
for (int frame = context->sync_frame;
frame != (context->is_backwards ? newframe - 1 : newframe + 1);
frame += frame_delta) {
MovieTrackingMarker marker;
libmv_Marker libmv_marker;
int clip = 0;
for (int i = 0; i < context->num_track_options; i++) {
AutoTrackOptions *track_options = &context->track_options[i];
MovieTrackingTrack *track = track_options->track;
const int clip_index = track_options->clip_index;
const int track_index = track_options->track_index;
const int track_frame = BKE_movieclip_remap_scene_to_clip_frame(context->clips[clip_index],
frame);
if (track_options->is_failed) {
if (track_options->failed_frame == track_frame) {
MovieTrackingMarker *prev_marker = BKE_tracking_marker_get_exact(
track, context->is_backwards ? frame + 1 : frame - 1);
if (prev_marker) {
marker = *prev_marker;
marker.framenr = track_frame;
marker.flag |= MARKER_DISABLED;
BKE_tracking_marker_insert(track, &marker);
continue;
}
}
if ((context->is_backwards && track_options->failed_frame > track_frame) ||
(!context->is_backwards && track_options->failed_frame < track_frame)) {
continue;
}
}
if (libmv_autoTrackGetMarker(
context->autotrack, clip, track_frame, track_index, &libmv_marker)) {
libmv_marker_to_dna_marker(
&libmv_marker, context->frame_width, context->frame_height, &marker);
if (context->first_sync && frame == context->sync_frame) {
tracking_marker_insert_disabled(track, &marker, !context->is_backwards, false);
}
BKE_tracking_marker_insert(track, &marker);
tracking_marker_insert_disabled(track, &marker, context->is_backwards, false);
}
}
}
ListBase results_to_sync = context->results_to_sync;
BLI_listbase_clear(&context->results_to_sync);
BLI_spin_unlock(&context->spin_lock);
for (int clip = 0; clip < context->num_clips; clip++) {
MovieTracking *tracking = &context->clips[clip]->tracking;
BKE_tracking_dopesheet_tag_update(tracking);
LISTBASE_FOREACH_MUTABLE (AutoTrackTrackingResult *, autotrack_result, &results_to_sync) {
const libmv_Marker *libmv_marker = &autotrack_result->libmv_marker;
const int clip_index = libmv_marker->clip;
const int track_index = libmv_marker->track;
const AutoTrackClip *autotrack_clip = &context->autotrack_clips[clip_index];
const MovieClip *clip = autotrack_clip->clip;
const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
MovieTrackingTrack *track = autotrack_track->track;
const int start_clip_frame = BKE_movieclip_remap_scene_to_clip_frame(
clip, context->start_scene_frame);
const int first_result_frame = start_clip_frame + frame_delta;
/* Insert marker which corresponds to the tracking result. */
MovieTrackingMarker marker;
libmv_marker_to_dna_marker(
&autotrack_result->libmv_marker, autotrack_clip->width, autotrack_clip->height, &marker);
if (!autotrack_result->success) {
marker.flag |= MARKER_DISABLED;
}
BKE_tracking_marker_insert(track, &marker);
/* Insetr disabled marker at the end of tracked segment.
* When tracking forward the disabled marker is added at the next frame from the result,
* when tracking backwards the marker is added at the previous frame. */
tracking_marker_insert_disabled(track, &marker, context->is_backwards, false);
if (marker.framenr == first_result_frame) {
MovieTrackingMarker *prev_marker = BKE_tracking_marker_get_exact(
track, marker.framenr - frame_delta);
BLI_assert(prev_marker != NULL);
tracking_marker_insert_disabled(track, prev_marker, !context->is_backwards, false);
}
/* Update synchronized frame to the latest tracked fame from the current results. */
const int marker_scene_frame = BKE_movieclip_remap_clip_to_scene_frame(clip, marker.framenr);
if (context->is_backwards) {
context->synchronized_scene_frame = min_ii(context->synchronized_scene_frame,
marker_scene_frame);
}
else {
context->synchronized_scene_frame = max_ii(context->synchronized_scene_frame,
marker_scene_frame);
}
MEM_freeN(autotrack_result);
}
context->sync_frame = newframe;
context->first_sync = false;
for (int clip_index = 0; clip_index < context->num_clips; clip_index++) {
MovieTracking *tracking = &context->autotrack_clips[clip_index].clip->tracking;
BKE_tracking_dopesheet_tag_update(tracking);
}
}
/* TODO(sergey): Find a way to avoid this, somehow making all needed logic in
* BKE_autotrack_context_sync(). */
void BKE_autotrack_context_sync_user(AutoTrackContext *context, MovieClipUser *user)
{
user->framenr = context->sync_frame;
user->framenr = context->synchronized_scene_frame;
}
/** \} */
/* -------------------------------------------------------------------- */
/** \name Finalization.
* \{ */
void BKE_autotrack_context_finish(AutoTrackContext *context)
{
for (int clip_index = 0; clip_index < context->num_clips; clip_index++) {
MovieClip *clip = context->clips[clip_index];
const AutoTrackClip *autotrack_clip = &context->autotrack_clips[clip_index];
MovieClip *clip = autotrack_clip->clip;
ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking);
const int start_clip_frame = BKE_movieclip_remap_scene_to_clip_frame(
clip, context->start_scene_frame);
@ -570,9 +797,12 @@ void BKE_autotrack_context_finish(AutoTrackContext *context)
if ((plane_track->flag & PLANE_TRACK_AUTOKEY)) {
continue;
}
for (int i = 0; i < context->num_track_options; i++) {
const AutoTrackOptions *track_options = &context->track_options[i];
MovieTrackingTrack *track = track_options->track;
for (int track_index = 0; track_index < context->num_all_tracks; track_index++) {
const AutoTrackTrack *autotrack_track = &context->all_autotrack_tracks[track_index];
if (!autotrack_track->is_trackable) {
continue;
}
MovieTrackingTrack *track = autotrack_track->track;
if (BKE_tracking_plane_track_has_point_track(plane_track, track)) {
BKE_tracking_track_plane_from_existing_motion(plane_track, start_clip_frame);
break;
@ -584,10 +814,22 @@ void BKE_autotrack_context_finish(AutoTrackContext *context)
void BKE_autotrack_context_free(AutoTrackContext *context)
{
libmv_autoTrackDestroy(context->autotrack);
tracking_image_accessor_destroy(context->image_accessor);
MEM_freeN(context->track_options);
MEM_freeN(context->all_tracks);
if (context->autotrack != NULL) {
libmv_autoTrackDestroy(context->autotrack);
}
if (context->image_accessor != NULL) {
tracking_image_accessor_destroy(context->image_accessor);
}
MEM_SAFE_FREE(context->all_autotrack_tracks);
MEM_SAFE_FREE(context->autotrack_markers);
BLI_freelistN(&context->results_to_sync);
BLI_spin_end(&context->spin_lock);
MEM_freeN(context);
}
/** \} */