Code cleanup: use boolean instead of int for tracking API

source/blender/blenkernel/BKE_tracking.h

@@ -68,7 +68,7 @@ void BKE_tracking_get_projection_matrix(struct MovieTracking *tracking, struct M
 /* **** Clipboard **** */
 void BKE_tracking_clipboard_free(void);
 void BKE_tracking_clipboard_copy_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
-int BKE_tracking_clipboard_has_tracks(void);
+bool BKE_tracking_clipboard_has_tracks(void);
 void BKE_tracking_clipboard_paste_tracks(struct MovieTracking *tracking, struct MovieTrackingObject *object);
 
 /* **** Track **** */
@@ -80,8 +80,8 @@ void BKE_tracking_track_free(struct MovieTrackingTrack *track);
 void BKE_tracking_track_flag_set(struct MovieTrackingTrack *track, int area, int flag);
 void BKE_tracking_track_flag_clear(struct MovieTrackingTrack *track, int area, int flag);
 
-int BKE_tracking_track_has_marker_at_frame(struct MovieTrackingTrack *track, int framenr);
+bool BKE_tracking_track_has_marker_at_frame(struct MovieTrackingTrack *track, int framenr);
-int BKE_tracking_track_has_enabled_marker_at_frame(struct MovieTrackingTrack *track, int framenr);
+bool BKE_tracking_track_has_enabled_marker_at_frame(struct MovieTrackingTrack *track, int framenr);
 
 void BKE_tracking_track_path_clear(struct MovieTrackingTrack *track, int ref_frame, int action);
 void BKE_tracking_tracks_join(struct MovieTracking *tracking, struct MovieTrackingTrack *dst_track, struct MovieTrackingTrack *src_track);
@@ -98,7 +98,7 @@ float *BKE_tracking_track_get_mask(int frame_width, int frame_height, struct Mov
                                    struct MovieTrackingMarker *marker);
 
 /* selection */
-void BKE_tracking_track_select(struct ListBase *tracksbase, struct MovieTrackingTrack *track, int area, int extend);
+void BKE_tracking_track_select(struct ListBase *tracksbase, struct MovieTrackingTrack *track, int area, bool extend);
 void BKE_tracking_track_deselect(struct MovieTrackingTrack *track, int area);
 void BKE_tracking_tracks_deselect_all(struct ListBase *tracksbase);
 
@@ -145,7 +145,7 @@ struct MovieTrackingPlaneMarker *BKE_tracking_plane_marker_ensure(struct MovieTr
 
 /* **** Object **** */
 struct MovieTrackingObject *BKE_tracking_object_add(struct MovieTracking *tracking, const char *name);
-int BKE_tracking_object_delete(struct MovieTracking *tracking, struct MovieTrackingObject *object);
+bool BKE_tracking_object_delete(struct MovieTracking *tracking, struct MovieTrackingObject *object);
 
 void BKE_tracking_object_unique_name(struct MovieTracking *tracking, struct MovieTrackingObject *object);
 
@@ -178,7 +178,7 @@ void BKE_tracking_distortion_update(struct MovieDistortion *distortion, struct M
 void BKE_tracking_distortion_set_threads(struct MovieDistortion *distortion, int threads);
 struct MovieDistortion *BKE_tracking_distortion_copy(struct MovieDistortion *distortion);
 struct ImBuf *BKE_tracking_distortion_exec(struct MovieDistortion *distortion, struct MovieTracking *tracking,
-                                           struct ImBuf *ibuf, int width, int height, float overscan, int undistort);
+                                           struct ImBuf *ibuf, int width, int height, float overscan, bool undistort);
 void BKE_tracking_distortion_free(struct MovieDistortion *distortion);
 
 void BKE_tracking_distort_v2(struct MovieTracking *tracking, const float co[2], float r_co[2]);
@@ -194,15 +194,15 @@ void BKE_tracking_max_undistortion_delta_across_bound(struct MovieTracking *trac
 /* **** Image sampling **** */
 struct ImBuf *BKE_tracking_sample_pattern(int frame_width, int frame_height,
                                           struct ImBuf *struct_ibuf, struct MovieTrackingTrack *track,
-                                          struct MovieTrackingMarker *marker, int from_anchor, int use_mask,
+                                          struct MovieTrackingMarker *marker, bool from_anchor, bool use_mask,
                                           int num_samples_x, int num_samples_y, float pos[2]);
 struct ImBuf *BKE_tracking_get_pattern_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
-                                             struct MovieTrackingMarker *marker, int anchored, int disable_channels);
+                                             struct MovieTrackingMarker *marker, bool anchored, bool disable_channels);
 struct ImBuf *BKE_tracking_get_search_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
-                                            struct MovieTrackingMarker *marker, int anchored, int disable_channels);
+                                            struct MovieTrackingMarker *marker, bool anchored, bool disable_channels);
 
-void BKE_tracking_disable_channels(struct ImBuf *ibuf, int disable_red, int disable_green,
+void BKE_tracking_disable_channels(struct ImBuf *ibuf, bool disable_red, bool disable_green,
-                                   int disable_blue, int grayscale);
+                                   bool disable_blue, bool grayscale);
 
 /* **** 2D tracking **** */
 struct MovieTrackingContext *BKE_tracking_context_new(struct MovieClip *clip, struct MovieClipUser *user,
@@ -210,8 +210,8 @@ struct MovieTrackingContext *BKE_tracking_context_new(struct MovieClip *clip, st
 void BKE_tracking_context_free(struct MovieTrackingContext *context);
 void BKE_tracking_context_sync(struct MovieTrackingContext *context);
 void BKE_tracking_context_sync_user(const struct MovieTrackingContext *context, struct MovieClipUser *user);
-int BKE_tracking_context_step(struct MovieTrackingContext *context);
+bool BKE_tracking_context_step(struct MovieTrackingContext *context);
-void BKE_tracking_refine_marker(struct MovieClip *clip, struct MovieTrackingTrack *track, struct MovieTrackingMarker *marker, int backwards);
+void BKE_tracking_refine_marker(struct MovieClip *clip, struct MovieTrackingTrack *track, struct MovieTrackingMarker *marker, bool backwards);
 
 /* **** Plane tracking **** */
 
@@ -219,7 +219,7 @@ void BKE_tracking_track_plane_from_existing_motion(struct MovieTrackingPlaneTrac
 void BKE_tracking_homography_between_two_quads(/*const*/ float reference_corners[4][2], /*const*/ float corners[4][2], float H[3][3]);
 
 /* **** Camera solving **** */
-int BKE_tracking_reconstruction_check(struct MovieTracking *tracking, struct MovieTrackingObject *object,
+bool BKE_tracking_reconstruction_check(struct MovieTracking *tracking, struct MovieTrackingObject *object,
                                        char *error_msg, int error_size);
 
 struct MovieReconstructContext *BKE_tracking_reconstruction_context_new(struct MovieTracking *tracking,
@@ -229,14 +229,14 @@ struct MovieReconstructContext *BKE_tracking_reconstruction_context_new(struct M
 void BKE_tracking_reconstruction_context_free(struct MovieReconstructContext *context);
 void BKE_tracking_reconstruction_solve(struct MovieReconstructContext *context, short *stop, short *do_update,
                                        float *progress, char *stats_message, int message_size);
-int BKE_tracking_reconstruction_finish(struct MovieReconstructContext *context, struct MovieTracking *tracking);
+bool BKE_tracking_reconstruction_finish(struct MovieReconstructContext *context, struct MovieTracking *tracking);
 
 void BKE_tracking_reconstruction_scale(struct MovieTracking *tracking, float scale[3]);
 
 /* **** Feature detection **** */
 void BKE_tracking_detect_fast(struct MovieTracking *tracking, struct ListBase *tracksbase, struct ImBuf *imbuf,
                               int framenr, int margin, int min_trackness, int min_distance, struct bGPDlayer *layer,
-                              int place_outside_layer);
+                              bool place_outside_layer);
 
 /* **** 2D stabilization **** */
 void BKE_tracking_stabilization_data_get(struct MovieTracking *tracking, int framenr, int width, int height,

source/blender/blenkernel/intern/tracking.c

@@ -501,7 +501,7 @@ void BKE_tracking_clipboard_copy_tracks(MovieTracking *tracking, MovieTrackingOb
 }
 
 /* Check whether there're any tracks in the clipboard. */
-int BKE_tracking_clipboard_has_tracks(void)
+bool BKE_tracking_clipboard_has_tracks(void)
 {
 	return tracking_clipboard.tracks.first != NULL;
 }
@@ -678,7 +678,7 @@ void BKE_tracking_track_flag_clear(MovieTrackingTrack *track, int area, int flag
  *
  * NOTE: frame number should be in clip space, not scene space.
  */
-int BKE_tracking_track_has_marker_at_frame(MovieTrackingTrack *track, int framenr)
+bool BKE_tracking_track_has_marker_at_frame(MovieTrackingTrack *track, int framenr)
 {
 	return BKE_tracking_marker_get_exact(track, framenr) != NULL;
 }
@@ -687,7 +687,7 @@ int BKE_tracking_track_has_marker_at_frame(MovieTrackingTrack *track, int framen
  *
  * NOTE: frame number should be in clip space, not scene space.
  */
-int BKE_tracking_track_has_enabled_marker_at_frame(MovieTrackingTrack *track, int framenr)
+bool BKE_tracking_track_has_enabled_marker_at_frame(MovieTrackingTrack *track, int framenr)
 {
 	MovieTrackingMarker *marker = BKE_tracking_marker_get_exact(track, framenr);
 
@@ -1022,7 +1022,7 @@ float *BKE_tracking_track_get_mask(int frame_width, int frame_height,
 }
 
 /* area - which part of marker should be selected. see TRACK_AREA_* constants */
-void BKE_tracking_track_select(ListBase *tracksbase, MovieTrackingTrack *track, int area, int extend)
+void BKE_tracking_track_select(ListBase *tracksbase, MovieTrackingTrack *track, int area, bool extend)
 {
 	if (extend) {
 		BKE_tracking_track_flag_set(track, area, SELECT);
@@ -1641,17 +1641,17 @@ MovieTrackingObject *BKE_tracking_object_add(MovieTracking *tracking, const char
 	return object;
 }
 
-int BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *object)
+bool BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *object)
 {
 	MovieTrackingTrack *track;
 	int index = BLI_findindex(&tracking->objects, object);
 
 	if (index == -1)
-		return FALSE;
+		return false;
 
 	if (object->flag & TRACKING_OBJECT_CAMERA) {
 		/* object used for camera solving can't be deleted */
-		return FALSE;
+		return false;
 	}
 
 	track = object->tracks.first;
@@ -1674,7 +1674,7 @@ int BKE_tracking_object_delete(MovieTracking *tracking, MovieTrackingObject *obj
 
 	BKE_tracking_dopesheet_tag_update(tracking);
 
-	return TRUE;
+	return true;
 }
 
 void BKE_tracking_object_unique_name(MovieTracking *tracking, MovieTrackingObject *object)
@@ -1947,7 +1947,7 @@ MovieDistortion *BKE_tracking_distortion_copy(MovieDistortion *distortion)
 }
 
 ImBuf *BKE_tracking_distortion_exec(MovieDistortion *distortion, MovieTracking *tracking, ImBuf *ibuf,
-                                    int calibration_width, int calibration_height, float overscan, int undistort)
+                                    int calibration_width, int calibration_height, float overscan, bool undistort)
 {
 	ImBuf *resibuf;
 
@@ -2039,7 +2039,7 @@ ImBuf *BKE_tracking_undistort_frame(MovieTracking *tracking, ImBuf *ibuf, int ca
 		camera->intrinsics = BKE_tracking_distortion_new();
 
 	return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, calibration_width,
-	                                    calibration_height, overscan, TRUE);
+	                                    calibration_height, overscan, true);
 }
 
 ImBuf *BKE_tracking_distort_frame(MovieTracking *tracking, ImBuf *ibuf, int calibration_width,
@@ -2051,7 +2051,7 @@ ImBuf *BKE_tracking_distort_frame(MovieTracking *tracking, ImBuf *ibuf, int cali
 		camera->intrinsics = BKE_tracking_distortion_new();
 
 	return BKE_tracking_distortion_exec(camera->intrinsics, tracking, ibuf, calibration_width,
-	                                    calibration_height, overscan, FALSE);
+	                                    calibration_height, overscan, false);
 }
 
 void BKE_tracking_max_undistortion_delta_across_bound(MovieTracking *tracking, rcti *rect, float delta[2])
@@ -2117,7 +2117,7 @@ void BKE_tracking_max_undistortion_delta_across_bound(MovieTracking *tracking, r
 
 /*********************** Image sampling *************************/
 
-static void disable_imbuf_channels(ImBuf *ibuf, MovieTrackingTrack *track, int grayscale)
+static void disable_imbuf_channels(ImBuf *ibuf, MovieTrackingTrack *track, bool grayscale)
 {
 	BKE_tracking_disable_channels(ibuf, track->flag & TRACK_DISABLE_RED,
 	                              track->flag & TRACK_DISABLE_GREEN,
@@ -2126,7 +2126,7 @@ static void disable_imbuf_channels(ImBuf *ibuf, MovieTrackingTrack *track, int g
 
 ImBuf *BKE_tracking_sample_pattern(int frame_width, int frame_height, ImBuf *search_ibuf,
                                    MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                                   int from_anchor, int use_mask, int num_samples_x, int num_samples_y,
+                                   bool from_anchor, bool use_mask, int num_samples_x, int num_samples_y,
                                    float pos[2])
 {
 	ImBuf *pattern_ibuf;
@@ -2189,7 +2189,7 @@ ImBuf *BKE_tracking_sample_pattern(int frame_width, int frame_height, ImBuf *sea
 }
 
 ImBuf *BKE_tracking_get_pattern_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                                      int anchored, int disable_channels)
+                                      bool anchored, bool disable_channels)
 {
 	ImBuf *pattern_ibuf, *search_ibuf;
 	float pat_min[2], pat_max[2];
@@ -2204,7 +2204,7 @@ ImBuf *BKE_tracking_get_pattern_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, Mo
 
 	if (search_ibuf) {
 		pattern_ibuf = BKE_tracking_sample_pattern(ibuf->x, ibuf->y, search_ibuf, track, marker,
-		                                           anchored, FALSE, num_samples_x, num_samples_y, NULL);
+		                                           anchored, false, num_samples_x, num_samples_y, NULL);
 
 		IMB_freeImBuf(search_ibuf);
 	}
@@ -2216,7 +2216,7 @@ ImBuf *BKE_tracking_get_pattern_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, Mo
 }
 
 ImBuf *BKE_tracking_get_search_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
-                                     int anchored, int disable_channels)
+                                     bool anchored, bool disable_channels)
 {
 	ImBuf *searchibuf;
 	int x, y, w, h;
@@ -2248,7 +2248,7 @@ ImBuf *BKE_tracking_get_search_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, Mov
 		    (track->flag & TRACK_DISABLE_GREEN)     ||
 		    (track->flag & TRACK_DISABLE_BLUE))
 		{
-			disable_imbuf_channels(searchibuf, track, TRUE);
+			disable_imbuf_channels(searchibuf, track, true);
 		}
 	}
 
@@ -2259,8 +2259,8 @@ ImBuf *BKE_tracking_get_search_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, Mov
  * better tracks sometimes. however, instead of simply zeroing the channels
  * out, do a partial grayscale conversion so the display is better.
  */
-void BKE_tracking_disable_channels(ImBuf *ibuf, int disable_red, int disable_green, int disable_blue,
+void BKE_tracking_disable_channels(ImBuf *ibuf, bool disable_red, bool disable_green, bool disable_blue,
-                                   int grayscale)
+                                   bool grayscale)
 {
 	int x, y;
 	float scale;
@@ -2324,7 +2324,7 @@ void BKE_tracking_disable_channels(ImBuf *ibuf, int disable_red, int disable_gre
 
 typedef struct TracksMap {
 	char object_name[MAX_NAME];
-	int is_camera;
+	bool is_camera;
 
 	int num_tracks;
 	int customdata_size;
@@ -2337,7 +2337,7 @@ typedef struct TracksMap {
 	int ptr;
 } TracksMap;
 
-static TracksMap *tracks_map_new(const char *object_name, int is_camera, int num_tracks, int customdata_size)
+static TracksMap *tracks_map_new(const char *object_name, bool is_camera, int num_tracks, int customdata_size)
 {
 	TracksMap *map = MEM_callocN(sizeof(TracksMap), "TrackingsMap");
 
@@ -2531,7 +2531,7 @@ typedef struct MovieTrackingContext {
 	MovieTrackingSettings settings;
 	TracksMap *tracks_map;
 
-	short backwards, sequence;
+	bool backwards, sequence;
 	int sync_frame;
 } MovieTrackingContext;
 
@@ -2704,7 +2704,7 @@ static float *track_get_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track,
 	float *gray_pixels;
 	int width, height;
 
-	searchibuf = BKE_tracking_get_search_imbuf(ibuf, track, marker, FALSE, TRUE);
+	searchibuf = BKE_tracking_get_search_imbuf(ibuf, track, marker, false, true);
 
 	if (!searchibuf) {
 		*width_r = 0;
@@ -3057,7 +3057,7 @@ static bool configure_and_run_tracker(ImBuf *destination_ibuf, MovieTrackingTrac
 /* Track all the tracks from context one more frame,
  * returns FALSe if nothing was tracked.
  */
-int BKE_tracking_context_step(MovieTrackingContext *context)
+bool BKE_tracking_context_step(MovieTrackingContext *context)
 {
 	ImBuf *destination_ibuf;
 	int frame_delta = context->backwards ? -1 : 1;
@@ -3071,7 +3071,7 @@ int BKE_tracking_context_step(MovieTrackingContext *context)
 
 	/* Nothing to track, avoid unneeded frames reading to save time and memory. */
 	if (!map_size)
-		return FALSE;
+		return false;
 
 	/* Get an image buffer for frame we're tracking to. */
 	context->user.framenr += frame_delta;
@@ -3079,7 +3079,7 @@ int BKE_tracking_context_step(MovieTrackingContext *context)
 	destination_ibuf = BKE_movieclip_get_ibuf_flag(context->clip, &context->user,
 	                                               context->clip_flag, MOVIECLIP_CACHE_SKIP);
 	if (!destination_ibuf)
-		return FALSE;
+		return false;
 
 	frame_width = destination_ibuf->x;
 	frame_height = destination_ibuf->y;
@@ -3146,7 +3146,7 @@ int BKE_tracking_context_step(MovieTrackingContext *context)
  * which means if backwards is false, previous keyframe will be as
  * reference.
  */
-void BKE_tracking_refine_marker(MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker, int backwards)
+void BKE_tracking_refine_marker(MovieClip *clip, MovieTrackingTrack *track, MovieTrackingMarker *marker, bool backwards)
 {
 	MovieTrackingMarker *reference_marker = NULL;
 	ImBuf *reference_ibuf, *destination_ibuf;
@@ -3369,7 +3369,7 @@ typedef struct MovieReconstructContext {
 	struct libmv_Reconstruction *reconstruction;
 
 	char object_name[MAX_NAME];
-	int is_camera;
+	bool is_camera;
 	short motion_flag;
 
 	float focal_length;
@@ -3383,7 +3383,7 @@ typedef struct MovieReconstructContext {
 	TracksMap *tracks_map;
 
 	float success_threshold;
-	int use_fallback_reconstruction;
+	bool use_fallback_reconstruction;
 
 	int sfra, efra;
 } MovieReconstructContext;
@@ -3452,7 +3452,7 @@ static void reconstruct_retrieve_libmv_intrinsics(MovieReconstructContext *conte
  * Actually, this also copies reconstructed cameras
  * from libmv to movie clip datablock.
  */
-static int reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, MovieTracking *tracking)
+static bool reconstruct_retrieve_libmv_tracks(MovieReconstructContext *context, MovieTracking *tracking)
 {
 	struct libmv_Reconstruction *libmv_reconstruction = context->reconstruction;
 	MovieTrackingReconstruction *reconstruction = NULL;
@@ -3629,12 +3629,12 @@ static int reconstruct_count_tracks_on_both_keyframes(MovieTracking *tracking, M
 }
 
 /* Perform early check on whether everything is fine to start reconstruction. */
-int BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObject *object,
+bool BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObject *object,
                                        char *error_msg, int error_size)
 {
 	if (tracking->settings.motion_flag & TRACKING_MOTION_MODAL) {
 		/* TODO: check for number of tracks? */
-		return TRUE;
+		return true;
 	}
 	else if ((tracking->settings.reconstruction_flag & TRACKING_USE_KEYFRAME_SELECTION) == 0) {
 		/* automatic keyframe selection does not require any pre-process checks */
@@ -3643,16 +3643,16 @@ int BKE_tracking_reconstruction_check(MovieTracking *tracking, MovieTrackingObje
 			            N_("At least 8 common tracks on both of keyframes are needed for reconstruction"),
 			            error_size);
 
-			return FALSE;
+			return false;
 		}
 	}
 
 #ifndef WITH_LIBMV
 	BLI_strncpy(error_msg, N_("Blender is compiled without motion tracking library"), error_size);
-	return FALSE;
+	return false;
 #endif
 
-	return TRUE;
+	return true;
 }
 
 /* Create context for camera/object motion reconstruction.
@@ -3846,7 +3846,7 @@ void BKE_tracking_reconstruction_solve(MovieReconstructContext *context, short *
 /* Finish reconstruction process by copying reconstructed data
  * to an actual movie clip datablock.
  */
-int BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTracking *tracking)
+bool BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTracking *tracking)
 {
 	MovieTrackingReconstruction *reconstruction;
 	MovieTrackingObject *object;
@@ -3871,9 +3871,9 @@ int BKE_tracking_reconstruction_finish(MovieReconstructContext *context, MovieTr
 	reconstruction->flag |= TRACKING_RECONSTRUCTED;
 
 	if (!reconstruct_retrieve_libmv(context, tracking))
-		return FALSE;
+		return false;
 
-	return TRUE;
+	return true;
 }
 
 static void tracking_scale_reconstruction(ListBase *tracksbase, MovieTrackingReconstruction *reconstruction,
@@ -4038,7 +4038,7 @@ static unsigned char *detect_get_frame_ucharbuf(ImBuf *ibuf)
 /* Detect features using FAST detector */
 void BKE_tracking_detect_fast(MovieTracking *tracking, ListBase *tracksbase, ImBuf *ibuf,
                               int framenr, int margin, int min_trackness, int min_distance, bGPDlayer *layer,
-                              int place_outside_layer)
+                              bool place_outside_layer)
 {
 	struct libmv_Features *features;
 	unsigned char *pixels = detect_get_frame_ucharbuf(ibuf);
@@ -4050,7 +4050,7 @@ void BKE_tracking_detect_fast(MovieTracking *tracking, ListBase *tracksbase, ImB
 
 	detect_retrieve_libmv_features(tracking, tracksbase, features,
 	                               framenr, ibuf->x, ibuf->y, layer,
-	                               place_outside_layer ? true : false);
+	                               place_outside_layer);
 
 	libmv_featuresDestroy(features);
 }
@@ -4664,7 +4664,7 @@ static void tracking_dopesheet_channels_calc(MovieTracking *tracking)
 /* Sot dopesheet channels using given method (name, average error, total coverage,
  * longest tracked segment) and could also inverse the list if it's enabled.
  */
-static void tracking_dopesheet_channels_sort(MovieTracking *tracking, int sort_method, int inverse)
+static void tracking_dopesheet_channels_sort(MovieTracking *tracking, int sort_method, bool inverse)
 {
 	MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
 
@@ -4801,7 +4801,7 @@ void BKE_tracking_dopesheet_update(MovieTracking *tracking)
 	MovieTrackingDopesheet *dopesheet = &tracking->dopesheet;
 
 	short sort_method = dopesheet->sort_method;
-	short inverse = dopesheet->flag & TRACKING_DOPE_SORT_INVERSE;
+	bool inverse = (dopesheet->flag & TRACKING_DOPE_SORT_INVERSE) != 0;
 
 	if (dopesheet->ok)
 		return;