From e12c08e8d170b7ca40f204a5b0423c23a9fbc2c1 Mon Sep 17 00:00:00 2001 From: Campbell Barton Date: Wed, 17 Apr 2019 06:17:24 +0200 Subject: ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat --- source/blender/blenkernel/intern/tracking_auto.c | 889 ++++++++++------------- 1 file changed, 400 insertions(+), 489 deletions(-) (limited to 'source/blender/blenkernel/intern/tracking_auto.c') diff --git a/source/blender/blenkernel/intern/tracking_auto.c b/source/blender/blenkernel/intern/tracking_auto.c index bddb5315781..e93a5780b81 100644 --- a/source/blender/blenkernel/intern/tracking_auto.c +++ b/source/blender/blenkernel/intern/tracking_auto.c @@ -27,7 +27,7 @@ #include "MEM_guardedalloc.h" #include "DNA_movieclip_types.h" -#include "DNA_object_types.h" /* SELECT */ +#include "DNA_object_types.h" /* SELECT */ #include "BLI_utildefines.h" #include "BLI_listbase.h" @@ -42,54 +42,54 @@ #include "tracking_private.h" typedef struct AutoTrackOptions { - int clip_index; /** Index of the clip this track belogs 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. */ - bool use_keyframe_match; /* Keyframe pattern matching. */ - - /* TODO(sergey): A bit awkward to keep it in here, only used to - * place a disabled marker once the tracking fails, - * Wither find a more clear way to do it or call it track context - * or state, not options. - */ - bool is_failed; - int failed_frame; + int clip_index; /** Index of the clip this track belogs 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. */ + bool use_keyframe_match; /* Keyframe pattern matching. */ + + /* TODO(sergey): A bit awkward to keep it in here, only used to + * place a disabled marker once the tracking fails, + * Wither find a more clear way to do it or call it track context + * or state, not options. + */ + bool is_failed; + int failed_frame; } AutoTrackOptions; typedef struct AutoTrackContext { - MovieClip *clips[MAX_ACCESSOR_CLIP]; - int num_clips; + MovieClip *clips[MAX_ACCESSOR_CLIP]; + int num_clips; - MovieClipUser user; - int frame_width, frame_height; + MovieClipUser user; + int frame_width, frame_height; - struct libmv_AutoTrack *autotrack; - TrackingImageAccessor *image_accessor; + struct libmv_AutoTrack *autotrack; + TrackingImageAccessor *image_accessor; - int num_tracks; /* Number of tracks being tracked. */ - AutoTrackOptions *options; /* Per-tracking track options. */ + int num_tracks; /* Number of tracks being tracked. */ + AutoTrackOptions *options; /* Per-tracking track options. */ - /* Array of all tracks, indexed by track_index. */ - MovieTrackingTrack **tracks; + /* Array of all tracks, indexed by track_index. */ + MovieTrackingTrack **tracks; - bool backwards; - bool sequence; - int first_frame; - int sync_frame; - bool first_sync; - SpinLock spin_lock; + bool backwards; + bool sequence; + int first_frame; + int sync_frame; + bool first_sync; + SpinLock spin_lock; - bool step_ok; + bool step_ok; } AutoTrackContext; static void normalized_to_libmv_frame(const float normalized[2], const int frame_dimensions[2], float result[2]) { - result[0] = normalized[0] * frame_dimensions[0] - 0.5f; - result[1] = normalized[1] * frame_dimensions[1] - 0.5f; + result[0] = normalized[0] * frame_dimensions[0] - 0.5f; + result[1] = normalized[1] * frame_dimensions[1] - 0.5f; } static void normalized_relative_to_libmv_frame(const float normalized[2], @@ -97,16 +97,16 @@ static void normalized_relative_to_libmv_frame(const float normalized[2], const int frame_dimensions[2], float result[2]) { - result[0] = (normalized[0] + origin[0]) * frame_dimensions[0] - 0.5f; - result[1] = (normalized[1] + origin[1]) * frame_dimensions[1] - 0.5f; + result[0] = (normalized[0] + origin[0]) * frame_dimensions[0] - 0.5f; + result[1] = (normalized[1] + origin[1]) * frame_dimensions[1] - 0.5f; } static void libmv_frame_to_normalized(const float frame_coord[2], const int frame_dimensions[2], float result[2]) { - result[0] = (frame_coord[0] + 0.5f) / frame_dimensions[0]; - result[1] = (frame_coord[1] + 0.5f) / frame_dimensions[1]; + result[0] = (frame_coord[0] + 0.5f) / frame_dimensions[0]; + result[1] = (frame_coord[1] + 0.5f) / frame_dimensions[1]; } static void libmv_frame_to_normalized_relative(const float frame_coord[2], @@ -114,8 +114,8 @@ static void libmv_frame_to_normalized_relative(const float frame_coord[2], const int frame_dimensions[2], float result[2]) { - result[0] = (frame_coord[0] - origin[0]) / frame_dimensions[0]; - result[1] = (frame_coord[1] - origin[1]) / frame_dimensions[1]; + result[0] = (frame_coord[0] - origin[0]) / frame_dimensions[0]; + result[1] = (frame_coord[1] - origin[1]) / frame_dimensions[1]; } static void dna_marker_to_libmv_marker(/*const*/ MovieTrackingTrack *track, @@ -127,67 +127,55 @@ static void dna_marker_to_libmv_marker(/*const*/ MovieTrackingTrack *track, bool backwards, libmv_Marker *libmv_marker) { - const int frame_dimensions[2] = {frame_width, frame_height}; - int i; - libmv_marker->clip = clip; - libmv_marker->frame = marker->framenr; - libmv_marker->track = track_index; - - normalized_to_libmv_frame(marker->pos, - frame_dimensions, - libmv_marker->center); - for (i = 0; i < 4; ++i) { - normalized_relative_to_libmv_frame(marker->pattern_corners[i], - marker->pos, - frame_dimensions, - libmv_marker->patch[i]); - } - - normalized_relative_to_libmv_frame(marker->search_min, - marker->pos, - frame_dimensions, - libmv_marker->search_region_min); - - 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. */ - libmv_marker->weight = 1.0f; - - if (marker->flag & MARKER_TRACKED) { - libmv_marker->source = LIBMV_MARKER_SOURCE_TRACKED; - } - else { - libmv_marker->source = LIBMV_MARKER_SOURCE_MANUAL; - } - libmv_marker->status = LIBMV_MARKER_STATUS_UNKNOWN; - 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. - */ - libmv_marker->reference_clip = clip; - - if (track->pattern_match == TRACK_MATCH_KEYFRAME) { - MovieTrackingMarker *keyframe_marker = - tracking_get_keyframed_marker(track, - marker->framenr, - backwards); - libmv_marker->reference_frame = keyframe_marker->framenr; - } - else { - libmv_marker->reference_frame = backwards ? - marker->framenr - 1 : - marker->framenr; - } - - libmv_marker->disabled_channels = - ((track->flag & TRACK_DISABLE_RED) ? LIBMV_MARKER_CHANNEL_R : 0) | - ((track->flag & TRACK_DISABLE_GREEN) ? LIBMV_MARKER_CHANNEL_G : 0) | - ((track->flag & TRACK_DISABLE_BLUE) ? LIBMV_MARKER_CHANNEL_B : 0); + const int frame_dimensions[2] = {frame_width, frame_height}; + int i; + libmv_marker->clip = clip; + libmv_marker->frame = marker->framenr; + libmv_marker->track = track_index; + + normalized_to_libmv_frame(marker->pos, frame_dimensions, libmv_marker->center); + for (i = 0; i < 4; ++i) { + normalized_relative_to_libmv_frame( + marker->pattern_corners[i], marker->pos, frame_dimensions, libmv_marker->patch[i]); + } + + normalized_relative_to_libmv_frame( + marker->search_min, marker->pos, frame_dimensions, libmv_marker->search_region_min); + + 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. */ + libmv_marker->weight = 1.0f; + + if (marker->flag & MARKER_TRACKED) { + libmv_marker->source = LIBMV_MARKER_SOURCE_TRACKED; + } + else { + libmv_marker->source = LIBMV_MARKER_SOURCE_MANUAL; + } + libmv_marker->status = LIBMV_MARKER_STATUS_UNKNOWN; + 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. + */ + libmv_marker->reference_clip = clip; + + if (track->pattern_match == TRACK_MATCH_KEYFRAME) { + MovieTrackingMarker *keyframe_marker = tracking_get_keyframed_marker( + track, marker->framenr, backwards); + libmv_marker->reference_frame = keyframe_marker->framenr; + } + else { + libmv_marker->reference_frame = backwards ? marker->framenr - 1 : marker->framenr; + } + + libmv_marker->disabled_channels = + ((track->flag & TRACK_DISABLE_RED) ? LIBMV_MARKER_CHANNEL_R : 0) | + ((track->flag & TRACK_DISABLE_GREEN) ? LIBMV_MARKER_CHANNEL_G : 0) | + ((track->flag & TRACK_DISABLE_BLUE) ? LIBMV_MARKER_CHANNEL_B : 0); } static void libmv_marker_to_dna_marker(libmv_Marker *libmv_marker, @@ -195,51 +183,43 @@ static void libmv_marker_to_dna_marker(libmv_Marker *libmv_marker, int frame_height, MovieTrackingMarker *marker) { - const int frame_dimensions[2] = {frame_width, frame_height}; - int i; - marker->framenr = libmv_marker->frame; - - libmv_frame_to_normalized(libmv_marker->center, - frame_dimensions, - marker->pos); - for (i = 0; i < 4; ++i) { - libmv_frame_to_normalized_relative(libmv_marker->patch[i], - libmv_marker->center, - frame_dimensions, - marker->pattern_corners[i]); - } - - libmv_frame_to_normalized_relative(libmv_marker->search_region_min, - libmv_marker->center, - frame_dimensions, - marker->search_min); - - libmv_frame_to_normalized_relative(libmv_marker->search_region_max, - libmv_marker->center, - frame_dimensions, - marker->search_max); - - marker->flag = 0; - if (libmv_marker->source == LIBMV_MARKER_SOURCE_TRACKED) { - marker->flag |= MARKER_TRACKED; - } - else { - marker->flag &= ~MARKER_TRACKED; - } + const int frame_dimensions[2] = {frame_width, frame_height}; + int i; + marker->framenr = libmv_marker->frame; + + libmv_frame_to_normalized(libmv_marker->center, frame_dimensions, marker->pos); + for (i = 0; i < 4; ++i) { + libmv_frame_to_normalized_relative(libmv_marker->patch[i], + libmv_marker->center, + frame_dimensions, + marker->pattern_corners[i]); + } + + libmv_frame_to_normalized_relative( + libmv_marker->search_region_min, libmv_marker->center, frame_dimensions, marker->search_min); + + libmv_frame_to_normalized_relative( + libmv_marker->search_region_max, libmv_marker->center, frame_dimensions, marker->search_max); + + marker->flag = 0; + if (libmv_marker->source == LIBMV_MARKER_SOURCE_TRACKED) { + marker->flag |= MARKER_TRACKED; + } + else { + marker->flag &= ~MARKER_TRACKED; + } } 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; + 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; } /* Returns false if marker crossed margin area from frame bounds. */ @@ -248,29 +228,28 @@ static bool tracking_check_marker_margin(libmv_Marker *libmv_marker, int frame_width, int frame_height) { - float patch_min[2], patch_max[2]; - float margin_left, margin_top, margin_right, margin_bottom; - - INIT_MINMAX2(patch_min, patch_max); - minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[0]); - minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[1]); - minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[2]); - minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[3]); - - margin_left = max_ff(libmv_marker->center[0] - patch_min[0], margin); - margin_top = max_ff(patch_max[1] - libmv_marker->center[1], margin); - margin_right = max_ff(patch_max[0] - libmv_marker->center[0], margin); - margin_bottom = max_ff(libmv_marker->center[1] - patch_min[1], margin); - - if (libmv_marker->center[0] < margin_left || - libmv_marker->center[0] > frame_width - margin_right || - libmv_marker->center[1] < margin_bottom || - libmv_marker->center[1] > frame_height - margin_top) - { - return false; - } - - return true; + float patch_min[2], patch_max[2]; + float margin_left, margin_top, margin_right, margin_bottom; + + INIT_MINMAX2(patch_min, patch_max); + minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[0]); + minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[1]); + minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[2]); + minmax_v2v2_v2(patch_min, patch_max, libmv_marker->patch[3]); + + margin_left = max_ff(libmv_marker->center[0] - patch_min[0], margin); + margin_top = max_ff(patch_max[1] - libmv_marker->center[1], margin); + margin_right = max_ff(patch_max[0] - libmv_marker->center[0], margin); + margin_bottom = max_ff(libmv_marker->center[1] - patch_min[1], margin); + + if (libmv_marker->center[0] < margin_left || + libmv_marker->center[0] > frame_width - margin_right || + libmv_marker->center[1] < margin_bottom || + libmv_marker->center[1] > frame_height - margin_top) { + return false; + } + + return true; } /* Provide Libmv side of auto track all information about given tracks. */ @@ -280,56 +259,47 @@ static void fill_autotrack_tracks(const int frame_width, const bool backwards, struct libmv_AutoTrack *autotrack) { - /* Count number of markers to be put to a context. */ - size_t num_trackable_markers = 0; - for (MovieTrackingTrack *track = tracksbase->first; - track != NULL; - track = track->next) - { - for (int i = 0; i < track->markersnr; ++i) { - const MovieTrackingMarker *marker = track->markers + i; - if ((marker->flag & MARKER_DISABLED) == 0) { - num_trackable_markers++; - } - } - } - /* Early output if we don't have any markers. */ - 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"); - /* Fill in markers array. */ - int track_index = 0, num_filled_libmv_markers = 0; - for (MovieTrackingTrack *track = tracksbase->first; - track != NULL; - track = track->next) - { - for (int i = 0; i < track->markersnr; ++i) { - MovieTrackingMarker *marker = track->markers + i; - if ((marker->flag & MARKER_DISABLED) != 0) { - continue; - } - dna_marker_to_libmv_marker( - track, - marker, - 0, - track_index, - frame_width, frame_height, - 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); - /* Free temporary memory. */ - MEM_freeN(libmv_markers); + /* Count number of markers to be put to a context. */ + size_t num_trackable_markers = 0; + for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) { + for (int i = 0; i < track->markersnr; ++i) { + const MovieTrackingMarker *marker = track->markers + i; + if ((marker->flag & MARKER_DISABLED) == 0) { + num_trackable_markers++; + } + } + } + /* Early output if we don't have any markers. */ + 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"); + /* Fill in markers array. */ + int track_index = 0, num_filled_libmv_markers = 0; + for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) { + for (int i = 0; i < track->markersnr; ++i) { + MovieTrackingMarker *marker = track->markers + i; + if ((marker->flag & MARKER_DISABLED) != 0) { + continue; + } + dna_marker_to_libmv_marker(track, + marker, + 0, + track_index, + frame_width, + frame_height, + 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); + /* Free temporary memory. */ + MEM_freeN(libmv_markers); } static void create_per_track_tracking_options(const MovieClip *clip, @@ -337,42 +307,32 @@ static void create_per_track_tracking_options(const MovieClip *clip, const ListBase *tracksbase, AutoTrackContext *context) { - /* Count number of trackable tracks. */ - for (MovieTrackingTrack *track = tracksbase->first; - track != NULL; - track = track->next) - { - if (check_track_trackable(clip, track, user)) { - context->num_tracks++; - } - } - /* Allocate required memory. */ - context->options = - MEM_callocN(sizeof(AutoTrackOptions) * context->num_tracks, - "auto track options"); - /* Fill in all the settings. */ - int i = 0, track_index = 0; - for (MovieTrackingTrack *track = tracksbase->first; - track != NULL; - track = track->next) - { - if (!check_track_trackable(clip, track, user)) { - ++track_index; - continue; - } - AutoTrackOptions *options = &context->options[i++]; - /* TODO(sergey): Single clip only for now. */ - options->clip_index = 0; - options->track_index = track_index; - options->track = track; - tracking_configure_tracker(track, - NULL, - &options->track_region_options); - options->use_keyframe_match = - track->pattern_match == TRACK_MATCH_KEYFRAME; - context->tracks[track_index] = track; - ++track_index; - } + /* Count number of trackable tracks. */ + for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) { + if (check_track_trackable(clip, track, user)) { + context->num_tracks++; + } + } + /* Allocate required memory. */ + context->options = MEM_callocN(sizeof(AutoTrackOptions) * context->num_tracks, + "auto track options"); + /* Fill in all the settings. */ + int i = 0, track_index = 0; + for (MovieTrackingTrack *track = tracksbase->first; track != NULL; track = track->next) { + if (!check_track_trackable(clip, track, user)) { + ++track_index; + continue; + } + AutoTrackOptions *options = &context->options[i++]; + /* TODO(sergey): Single clip only for now. */ + options->clip_index = 0; + options->track_index = track_index; + options->track = track; + tracking_configure_tracker(track, NULL, &options->track_region_options); + options->use_keyframe_match = track->pattern_match == TRACK_MATCH_KEYFRAME; + context->tracks[track_index] = track; + ++track_index; + } } AutoTrackContext *BKE_autotrack_context_new(MovieClip *clip, @@ -380,266 +340,217 @@ AutoTrackContext *BKE_autotrack_context_new(MovieClip *clip, const bool backwards, const bool sequence) { - 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->user = *user; - context->user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL; - context->user.render_flag = 0; - context->frame_width = frame_width; - context->frame_height = frame_height; - context->backwards = backwards; - context->sequence = sequence; - context->first_frame = user->framenr; - context->sync_frame = user->framenr; - context->first_sync = true; - BLI_spin_init(&context->spin_lock); - const int num_total_tracks = BLI_listbase_count(tracksbase); - context->tracks = - MEM_callocN(sizeof(MovieTrackingTrack *) * num_total_tracks, - "auto track pointers"); - /* Initialize image accessor. */ - context->image_accessor = - tracking_image_accessor_new(context->clips, 1, - context->tracks, num_total_tracks, - user->framenr); - /* 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, - backwards, - context->autotrack); - /* Create per-track tracking options. */ - create_per_track_tracking_options(clip, user, tracksbase, context); - return context; + 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->user = *user; + context->user.render_size = MCLIP_PROXY_RENDER_SIZE_FULL; + context->user.render_flag = 0; + context->frame_width = frame_width; + context->frame_height = frame_height; + context->backwards = backwards; + context->sequence = sequence; + context->first_frame = user->framenr; + context->sync_frame = user->framenr; + context->first_sync = true; + BLI_spin_init(&context->spin_lock); + const int num_total_tracks = BLI_listbase_count(tracksbase); + context->tracks = MEM_callocN(sizeof(MovieTrackingTrack *) * num_total_tracks, + "auto track pointers"); + /* Initialize image accessor. */ + context->image_accessor = tracking_image_accessor_new( + context->clips, 1, context->tracks, num_total_tracks, user->framenr); + /* 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, backwards, context->autotrack); + /* Create per-track tracking options. */ + create_per_track_tracking_options(clip, user, tracksbase, context); + return context; } -static void autotrack_context_step_cb( - void *__restrict userdata, - const int track, - const ParallelRangeTLS *__restrict UNUSED(tls)) +static void autotrack_context_step_cb(void *__restrict userdata, + const int track, + const ParallelRangeTLS *__restrict UNUSED(tls)) { - AutoTrackContext *context = userdata; - const int frame_delta = context->backwards ? -1 : 1; - - AutoTrackOptions *options = &context->options[track]; - if (options->is_failed) { - return; - } - libmv_Marker libmv_current_marker, - libmv_reference_marker, - libmv_tracked_marker; - libmv_TrackRegionResult libmv_result; - const int frame = BKE_movieclip_remap_scene_to_clip_frame( - context->clips[options->clip_index], - context->user.framenr); - BLI_spin_lock(&context->spin_lock); - const bool has_marker = libmv_autoTrackGetMarker(context->autotrack, - options->clip_index, - frame, - options->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, - options->track->margin, - context->frame_width, - context->frame_height)) - { - return; - } - libmv_tracked_marker = libmv_current_marker; - libmv_tracked_marker.frame = frame + frame_delta; - /* Update reference frame. */ - if (options->use_keyframe_match) { - libmv_tracked_marker.reference_frame = - libmv_current_marker.reference_frame; - libmv_autoTrackGetMarker(context->autotrack, - options->clip_index, - libmv_tracked_marker.reference_frame, - options->track_index, - &libmv_reference_marker); - } - else { - libmv_tracked_marker.reference_frame = frame; - libmv_reference_marker = libmv_current_marker; - } - /* Perform actual tracking. */ - if (libmv_autoTrackMarker(context->autotrack, - &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 { - options->is_failed = true; - options->failed_frame = frame + frame_delta; - } - - /* 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); + AutoTrackContext *context = userdata; + const int frame_delta = context->backwards ? -1 : 1; + + AutoTrackOptions *options = &context->options[track]; + if (options->is_failed) { + return; + } + libmv_Marker libmv_current_marker, libmv_reference_marker, libmv_tracked_marker; + libmv_TrackRegionResult libmv_result; + const int frame = BKE_movieclip_remap_scene_to_clip_frame(context->clips[options->clip_index], + context->user.framenr); + BLI_spin_lock(&context->spin_lock); + const bool has_marker = libmv_autoTrackGetMarker( + context->autotrack, options->clip_index, frame, options->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, + options->track->margin, + context->frame_width, + context->frame_height)) { + return; + } + libmv_tracked_marker = libmv_current_marker; + libmv_tracked_marker.frame = frame + frame_delta; + /* Update reference frame. */ + if (options->use_keyframe_match) { + libmv_tracked_marker.reference_frame = libmv_current_marker.reference_frame; + libmv_autoTrackGetMarker(context->autotrack, + options->clip_index, + libmv_tracked_marker.reference_frame, + options->track_index, + &libmv_reference_marker); + } + else { + libmv_tracked_marker.reference_frame = frame; + libmv_reference_marker = libmv_current_marker; + } + /* Perform actual tracking. */ + if (libmv_autoTrackMarker(context->autotrack, + &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 { + options->is_failed = true; + options->failed_frame = frame + frame_delta; + } + + /* 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); } bool BKE_autotrack_context_step(AutoTrackContext *context) { - const int frame_delta = context->backwards ? -1 : 1; - context->step_ok = false; - - ParallelRangeSettings settings; - BLI_parallel_range_settings_defaults(&settings); - settings.use_threading = (context->num_tracks > 1); - BLI_task_parallel_range(0, context->num_tracks, - context, - autotrack_context_step_cb, - &settings); - - /* Advance the frame. */ - BLI_spin_lock(&context->spin_lock); - context->user.framenr += frame_delta; - BLI_spin_unlock(&context->spin_lock); - return context->step_ok; + const int frame_delta = context->backwards ? -1 : 1; + context->step_ok = false; + + ParallelRangeSettings settings; + BLI_parallel_range_settings_defaults(&settings); + settings.use_threading = (context->num_tracks > 1); + BLI_task_parallel_range(0, context->num_tracks, context, autotrack_context_step_cb, &settings); + + /* Advance the frame. */ + BLI_spin_lock(&context->spin_lock); + context->user.framenr += frame_delta; + BLI_spin_unlock(&context->spin_lock); + return context->step_ok; } void BKE_autotrack_context_sync(AutoTrackContext *context) { - int newframe, frame_delta = context->backwards ? -1 : 1; - int frame; - - BLI_spin_lock(&context->spin_lock); - newframe = context->user.framenr; - for (frame = context->sync_frame; - frame != (context->backwards ? newframe - 1 : newframe + 1); - frame += frame_delta) - { - MovieTrackingMarker marker; - libmv_Marker libmv_marker; - int clip = 0; - int track; - for (track = 0; track < context->num_tracks; ++track) { - AutoTrackOptions *options = &context->options[track]; - int track_frame = BKE_movieclip_remap_scene_to_clip_frame( - context->clips[options->clip_index], frame); - if (options->is_failed) { - if (options->failed_frame == track_frame) { - MovieTrackingMarker *prev_marker = - BKE_tracking_marker_get_exact( - options->track, - context->backwards - ? frame + 1 - : frame - 1); - if (prev_marker) { - marker = *prev_marker; - marker.framenr = track_frame; - marker.flag |= MARKER_DISABLED; - BKE_tracking_marker_insert(options->track, &marker); - continue; - } - } - if ((context->backwards && options->failed_frame > track_frame) || - (!context->backwards && options->failed_frame < track_frame)) - { - continue; - } - } - if (libmv_autoTrackGetMarker(context->autotrack, - clip, - track_frame, - options->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(options->track, - &marker, - !context->backwards, - false); - } - BKE_tracking_marker_insert(options->track, &marker); - tracking_marker_insert_disabled(options->track, - &marker, - context->backwards, - false); - } - } - } - 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); - } - - context->sync_frame = newframe; - context->first_sync = false; + int newframe, frame_delta = context->backwards ? -1 : 1; + int frame; + + BLI_spin_lock(&context->spin_lock); + newframe = context->user.framenr; + for (frame = context->sync_frame; frame != (context->backwards ? newframe - 1 : newframe + 1); + frame += frame_delta) { + MovieTrackingMarker marker; + libmv_Marker libmv_marker; + int clip = 0; + int track; + for (track = 0; track < context->num_tracks; ++track) { + AutoTrackOptions *options = &context->options[track]; + int track_frame = BKE_movieclip_remap_scene_to_clip_frame( + context->clips[options->clip_index], frame); + if (options->is_failed) { + if (options->failed_frame == track_frame) { + MovieTrackingMarker *prev_marker = BKE_tracking_marker_get_exact( + options->track, context->backwards ? frame + 1 : frame - 1); + if (prev_marker) { + marker = *prev_marker; + marker.framenr = track_frame; + marker.flag |= MARKER_DISABLED; + BKE_tracking_marker_insert(options->track, &marker); + continue; + } + } + if ((context->backwards && options->failed_frame > track_frame) || + (!context->backwards && options->failed_frame < track_frame)) { + continue; + } + } + if (libmv_autoTrackGetMarker( + context->autotrack, clip, track_frame, options->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(options->track, &marker, !context->backwards, false); + } + BKE_tracking_marker_insert(options->track, &marker); + tracking_marker_insert_disabled(options->track, &marker, context->backwards, false); + } + } + } + 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); + } + + context->sync_frame = newframe; + context->first_sync = false; } -void BKE_autotrack_context_sync_user(AutoTrackContext *context, - MovieClipUser *user) +void BKE_autotrack_context_sync_user(AutoTrackContext *context, MovieClipUser *user) { - user->framenr = context->sync_frame; + user->framenr = context->sync_frame; } void BKE_autotrack_context_finish(AutoTrackContext *context) { - int clip_index; - - for (clip_index = 0; clip_index < context->num_clips; ++clip_index) { - MovieClip *clip = context->clips[clip_index]; - ListBase *plane_tracks_base = - BKE_tracking_get_active_plane_tracks(&clip->tracking); - MovieTrackingPlaneTrack *plane_track; - - for (plane_track = plane_tracks_base->first; - plane_track; - plane_track = plane_track->next) - { - if ((plane_track->flag & PLANE_TRACK_AUTOKEY) == 0) { - int track; - for (track = 0; track < context->num_tracks; ++track) { - if (BKE_tracking_plane_track_has_point_track( - plane_track, - context->options[track].track)) - { - BKE_tracking_track_plane_from_existing_motion( - plane_track, - context->first_frame); - break; - } - } - } - } - } + int clip_index; + + for (clip_index = 0; clip_index < context->num_clips; ++clip_index) { + MovieClip *clip = context->clips[clip_index]; + ListBase *plane_tracks_base = BKE_tracking_get_active_plane_tracks(&clip->tracking); + MovieTrackingPlaneTrack *plane_track; + + for (plane_track = plane_tracks_base->first; plane_track; plane_track = plane_track->next) { + if ((plane_track->flag & PLANE_TRACK_AUTOKEY) == 0) { + int track; + for (track = 0; track < context->num_tracks; ++track) { + if (BKE_tracking_plane_track_has_point_track(plane_track, + context->options[track].track)) { + BKE_tracking_track_plane_from_existing_motion(plane_track, context->first_frame); + break; + } + } + } + } + } } void BKE_autotrack_context_free(AutoTrackContext *context) { - libmv_autoTrackDestroy(context->autotrack); - tracking_image_accessor_destroy(context->image_accessor); - MEM_freeN(context->options); - MEM_freeN(context->tracks); - BLI_spin_end(&context->spin_lock); - MEM_freeN(context); + libmv_autoTrackDestroy(context->autotrack); + tracking_image_accessor_destroy(context->image_accessor); + MEM_freeN(context->options); + MEM_freeN(context->tracks); + BLI_spin_end(&context->spin_lock); + MEM_freeN(context); } -- cgit v1.2.3