struct MovieClip *BKE_add_movieclip_file(const char *name);
void BKE_movieclip_reload(struct MovieClip *clip);
-struct ImBuf *BKE_movieclip_acquire_ibuf(struct MovieClip *clip, struct MovieClipUser *user);
-struct ImBuf *BKE_movieclip_acquire_stable_ibuf(struct MovieClip *clip, struct MovieClipUser *user, float loc[2], float *scale, float *angle);
-struct ImBuf *BKE_movieclip_acquire_ibuf_flag(struct MovieClip *clip, struct MovieClipUser *user, int flag);
-void BKE_movieclip_acquire_size(struct MovieClip *clip, struct MovieClipUser *user, int *width, int *height);
+struct ImBuf *BKE_movieclip_get_ibuf(struct MovieClip *clip, struct MovieClipUser *user);
+struct ImBuf *BKE_movieclip_get_stable_ibuf(struct MovieClip *clip, struct MovieClipUser *user, float loc[2], float *scale, float *angle);
+struct ImBuf *BKE_movieclip_get_ibuf_flag(struct MovieClip *clip, struct MovieClipUser *user, int flag);
+void BKE_movieclip_get_size(struct MovieClip *clip, struct MovieClipUser *user, int *width, int *height);
void BKE_movieclip_aspect(struct MovieClip *clip, float *aspx, float *aspy);
int BKE_movieclip_has_frame(struct MovieClip *clip, struct MovieClipUser *user);
void BKE_movieclip_user_set_frame(struct MovieClipUser *user, int framenr);
void BKE_tracking_join_tracks(struct MovieTrackingTrack *dst_track, struct MovieTrackingTrack *src_track);
void BKE_tracking_free(struct MovieTracking *tracking);
-struct ImBuf *BKE_tracking_acquire_pattern_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
+struct ImBuf *BKE_tracking_get_pattern_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker, int margin, int anchored, float pos[2], int origin[2]);
-struct ImBuf *BKE_tracking_acquire_search_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
+struct ImBuf *BKE_tracking_get_search_imbuf(struct ImBuf *ibuf, struct MovieTrackingTrack *track,
struct MovieTrackingMarker *marker, int margin, int anchored, float pos[2], int origin[2]);
struct MovieTrackingContext *BKE_tracking_context_new(struct MovieClip *clip, struct MovieClipUser *user,
else clip->source= MCLIP_SRC_SEQUENCE;
user.framenr= 1;
- BKE_movieclip_acquire_size(clip, &user, &width, &height);
+ BKE_movieclip_get_size(clip, &user, &width, &height);
if(width && height) {
clip->tracking.camera.principal[0]= ((float)width)/2;
clip->tracking.camera.principal[1]= ((float)height)/2;
return cache->undistibuf;
}
-ImBuf *BKE_movieclip_acquire_ibuf(MovieClip *clip, MovieClipUser *user)
+ImBuf *BKE_movieclip_get_ibuf(MovieClip *clip, MovieClipUser *user)
{
ImBuf *ibuf= NULL;
int framenr= user?user->framenr:clip->lastframe;
return ibuf;
}
-ImBuf *BKE_movieclip_acquire_ibuf_flag(MovieClip *clip, MovieClipUser *user, int flag)
+ImBuf *BKE_movieclip_get_ibuf_flag(MovieClip *clip, MovieClipUser *user, int flag)
{
ImBuf *ibuf= NULL;
int framenr= user?user->framenr:clip->lastframe;
return ibuf;
}
-ImBuf *BKE_movieclip_acquire_stable_ibuf(MovieClip *clip, MovieClipUser *user, float loc[2], float *scale, float *angle)
+ImBuf *BKE_movieclip_get_stable_ibuf(MovieClip *clip, MovieClipUser *user, float loc[2], float *scale, float *angle)
{
ImBuf *ibuf, *stableibuf= NULL;
int framenr= user?user->framenr:clip->lastframe;
- ibuf= BKE_movieclip_acquire_ibuf(clip, user);
+ ibuf= BKE_movieclip_get_ibuf(clip, user);
if(!ibuf)
return NULL;
int BKE_movieclip_has_frame(MovieClip *clip, MovieClipUser *user)
{
- ImBuf *ibuf= BKE_movieclip_acquire_ibuf(clip, user);
+ ImBuf *ibuf= BKE_movieclip_get_ibuf(clip, user);
if(ibuf) {
IMB_freeImBuf(ibuf);
return 0;
}
-void BKE_movieclip_acquire_size(MovieClip *clip, MovieClipUser *user, int *width, int *height)
+void BKE_movieclip_get_size(MovieClip *clip, MovieClipUser *user, int *width, int *height)
{
if(!user || user->framenr==clip->lastframe) {
*width= clip->lastsize[0];
*height= clip->lastsize[1];
} else {
- ImBuf *ibuf= BKE_movieclip_acquire_ibuf(clip, user);
+ ImBuf *ibuf= BKE_movieclip_get_ibuf(clip, user);
if(ibuf && ibuf->x && ibuf->y) {
real_ibuf_size(clip, user, ibuf, width, height);
if(marker->flag&MARKER_DISABLED) {
scopes->track_disabled= 1;
} else {
- ImBuf *ibuf= BKE_movieclip_acquire_ibuf(clip, user);
+ ImBuf *ibuf= BKE_movieclip_get_ibuf(clip, user);
scopes->track_disabled= 0;
int width, height;
float aspy= 1.f/clip->tracking.camera.pixel_aspect;;
- BKE_movieclip_acquire_size(clip, user, &width, &height);
+ BKE_movieclip_get_size(clip, user, &width, &height);
undist_marker.pos[0]*= width;
undist_marker.pos[1]*= height*aspy;
undist_marker.pos[1]/= height*aspy;
}
- tmpibuf= BKE_tracking_acquire_pattern_imbuf(ibuf, track, &undist_marker, 1, 1, scopes->track_pos, NULL);
+ tmpibuf= BKE_tracking_get_pattern_imbuf(ibuf, track, &undist_marker, 1, 1, scopes->track_pos, NULL);
if(tmpibuf->rect_float)
IMB_rect_from_float(tmpibuf);
user.framenr= cfra;
- ibuf= BKE_movieclip_acquire_ibuf_flag(clip, &user, 0);
+ ibuf= BKE_movieclip_get_ibuf_flag(clip, &user, 0);
if(ibuf) {
ImBuf *tmpibuf= ibuf;
if(context->num_tracks) {
int width, height;
- BKE_movieclip_acquire_size(clip, user, &width, &height);
+ BKE_movieclip_get_size(clip, user, &width, &height);
/* create tracking data */
context->track_context= MEM_callocN(sizeof(TrackContext)*context->num_tracks, "tracking track_context");
}
}
-static ImBuf *acquire_area_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+static ImBuf *get_area_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
float min[2], float max[2], int margin, int anchored, float pos[2], int origin[2])
{
ImBuf *tmpibuf;
return tmpibuf;
}
-ImBuf *BKE_tracking_acquire_pattern_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+ImBuf *BKE_tracking_get_pattern_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
int margin, int anchored, float pos[2], int origin[2])
{
- return acquire_area_imbuf(ibuf, track, marker, track->pat_min, track->pat_max, margin, anchored, pos, origin);
+ return get_area_imbuf(ibuf, track, marker, track->pat_min, track->pat_max, margin, anchored, pos, origin);
}
-ImBuf *BKE_tracking_acquire_search_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+ImBuf *BKE_tracking_get_search_imbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
int margin, int anchored, float pos[2], int origin[2])
{
- return acquire_area_imbuf(ibuf, track, marker, track->search_min, track->search_max, margin, anchored, pos, origin);
+ return get_area_imbuf(ibuf, track, marker, track->search_min, track->search_max, margin, anchored, pos, origin);
}
#ifdef WITH_LIBMV
-static float *acquire_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+static float *get_search_floatbuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
int *width_r, int *height_r, float pos[2], int origin[2])
{
ImBuf *tmpibuf;
width= (track->search_max[0]-track->search_min[0])*ibuf->x;
height= (track->search_max[1]-track->search_min[1])*ibuf->y;
- tmpibuf= BKE_tracking_acquire_search_imbuf(ibuf, track, marker, 0, 0, pos, origin);
+ tmpibuf= BKE_tracking_get_search_imbuf(ibuf, track, marker, 0, 0, pos, origin);
disable_imbuf_channels(tmpibuf, track);
*width_r= width;
return pixels;
}
-static unsigned char *acquire_search_bytebuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+static unsigned char *get_search_bytebuf(ImBuf *ibuf, MovieTrackingTrack *track, MovieTrackingMarker *marker,
int *width_r, int *height_r, float pos[2], int origin[2])
{
ImBuf *tmpibuf;
width= (track->search_max[0]-track->search_min[0])*ibuf->x;
height= (track->search_max[1]-track->search_min[1])*ibuf->y;
- tmpibuf= BKE_tracking_acquire_search_imbuf(ibuf, track, marker, 0, 0, pos, origin);
+ tmpibuf= BKE_tracking_get_search_imbuf(ibuf, track, marker, 0, 0, pos, origin);
disable_imbuf_channels(tmpibuf, track);
*width_r= width;
return pixels;
}
-static ImBuf *acquire_frame_ibuf(MovieTrackingContext *context, int framenr)
+static ImBuf *get_frame_ibuf(MovieTrackingContext *context, int framenr)
{
ImBuf *ibuf;
int framenr_old= context->user.framenr;
context->user.framenr= framenr;
- ibuf= BKE_movieclip_acquire_ibuf_flag(context->clip, &context->user, 0);
+ ibuf= BKE_movieclip_get_ibuf_flag(context->clip, &context->user, 0);
context->user.framenr= framenr_old;
return ibuf;
}
-static ImBuf *acquire_keyframed_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track,
+static ImBuf *get_keyframed_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track,
MovieTrackingMarker *marker, MovieTrackingMarker **marker_keyed)
{
int framenr= marker->framenr;
else a--;
}
- return acquire_frame_ibuf(context, framenr);
+ return get_frame_ibuf(context, framenr);
}
-static ImBuf *acquire_adjust_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track, MovieTrackingMarker *marker,
+static ImBuf *get_adjust_ibuf(MovieTrackingContext *context, MovieTrackingTrack *track, MovieTrackingMarker *marker,
int curfra, MovieTrackingMarker **marker_keyed)
{
ImBuf *ibuf= NULL;
if(context->settings.adjframes == 0) {
- ibuf= acquire_keyframed_ibuf(context, track, marker, marker_keyed);
+ ibuf= get_keyframed_ibuf(context, track, marker, marker_keyed);
} else {
- ibuf= acquire_frame_ibuf(context, curfra);
+ ibuf= get_frame_ibuf(context, curfra);
/* use current marker as keyframed position */
*marker_keyed= marker;
return ibuf;
}
-static void acquire_warped(TrackContext *track_context, int x, int y, int width, unsigned char *image)
+static void get_warped(TrackContext *track_context, int x, int y, int width, unsigned char *image)
{
int i, j;
if(context->backwards) context->user.framenr--;
else context->user.framenr++;
- ibuf_new= BKE_movieclip_acquire_ibuf_flag(context->clip, &context->user, 0);
+ ibuf_new= BKE_movieclip_get_ibuf_flag(context->clip, &context->user, 0);
if(!ibuf_new)
return 0;
if(need_readjust) {
/* calculate patch for keyframed position */
- ibuf= acquire_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
+ ibuf= get_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
if(track_context->patch)
MEM_freeN(track_context->patch);
- track_context->patch= acquire_search_floatbuf(ibuf, track, marker_keyed, &width, &height, pos, origin);
+ track_context->patch= get_search_floatbuf(ibuf, track, marker_keyed, &width, &height, pos, origin);
IMB_freeImBuf(ibuf);
}
- patch_new= acquire_search_floatbuf(ibuf_new, track, marker, &width, &height, pos, origin);
+ patch_new= get_search_floatbuf(ibuf_new, track, marker, &width, &height, pos, origin);
x1= pos[0];
y1= pos[1];
unsigned char *image;
/* calculate pattern for keyframed position */
- ibuf= acquire_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
+ ibuf= get_adjust_ibuf(context, track, marker, curfra, &marker_keyed);
- image= acquire_search_bytebuf(ibuf, track, marker_keyed, &width, &height, pos, origin);
+ image= get_search_bytebuf(ibuf, track, marker_keyed, &width, &height, pos, origin);
memset(warp, 0, sizeof(warp));
warp[0][0]= 1;
IMB_freeImBuf(ibuf);
}
- image_new= acquire_search_bytebuf(ibuf_new, track, marker, &width, &height, pos, origin);
+ image_new= get_search_bytebuf(ibuf_new, track, marker, &width, &height, pos, origin);
if(track_context->warped==NULL) {
unsigned char *image_old;
- ibuf= acquire_frame_ibuf(context, curfra);
+ ibuf= get_frame_ibuf(context, curfra);
if(track_context->warped==NULL)
track_context->warped= MEM_callocN(sizeof(unsigned char)*track_context->patsize*track_context->patsize, "trackking warped");
- image_old= acquire_search_bytebuf(ibuf, track, marker, &width, &height, pos, origin);
- acquire_warped(track_context, pos[0], pos[1], width, image_old);
+ image_old= get_search_bytebuf(ibuf, track, marker, &width, &height, pos, origin);
+ get_warped(track_context, pos[0], pos[1], width, image_old);
IMB_freeImBuf(ibuf);
MEM_freeN(image_old);
}
tracked= corr>=context->settings.corr;
if(tracked)
- acquire_warped(track_context, x2, y2, width, image_new);
+ get_warped(track_context, x2, y2, width, image_new);
MEM_freeN(image_new);
}
}
#ifdef WITH_LIBMV
-static unsigned char *acquire_ucharbuf(ImBuf *ibuf)
+static unsigned char *get_ucharbuf(ImBuf *ibuf)
{
int x, y;
unsigned char *pixels, *fp;
{
#ifdef WITH_LIBMV
struct libmv_Features *features;
- unsigned char *pixels= acquire_ucharbuf(ibuf);
+ unsigned char *pixels= get_ucharbuf(ibuf);
features= libmv_detectFeaturesFAST(pixels, ibuf->x, ibuf->y, ibuf->x, margin, min_trackness, min_distance);
{
#ifdef WITH_LIBMV
struct libmv_Features *features;
- unsigned char *pixels= acquire_ucharbuf(ibuf);
+ unsigned char *pixels= get_ucharbuf(ibuf);
features= libmv_detectFeaturesMORAVEC(pixels, ibuf->x, ibuf->y, ibuf->x, margin, count, min_distance);
void ED_space_clip_zoom(struct SpaceClip *sc, ARegion *ar, float *zoomx, float *zoomy);
void ED_space_clip_aspect(struct SpaceClip *sc, float *aspx, float *aspy);
-struct ImBuf *ED_space_clip_acquire_buffer(struct SpaceClip *sc);
-struct ImBuf *ED_space_clip_acquire_stable_buffer(struct SpaceClip *sc, float loc[2], float *scale, float *angle);
+struct ImBuf *ED_space_clip_get_buffer(struct SpaceClip *sc);
+struct ImBuf *ED_space_clip_get_stable_buffer(struct SpaceClip *sc, float loc[2], float *scale, float *angle);
void ED_clip_update_frame(const struct Main *mainp, int cfra);
void ED_clip_view_selection(struct SpaceClip *sc, struct ARegion *ar, int fit);
MovieTrackingMarker *marker;
int width, height, ok= 0;
- BKE_movieclip_acquire_size(cb->clip, cb->user, &width, &height);
+ BKE_movieclip_get_size(cb->clip, cb->user, &width, &height);
marker= BKE_tracking_ensure_marker(cb->track, cb->framenr);
float pat_dim[2], pat_pos[2], search_dim[2], search_pos[2];
uiLayout *col;
- BKE_movieclip_acquire_size(clip, user, &width, &height);
+ BKE_movieclip_get_size(clip, user, &width, &height);
if(track->flag&TRACK_LOCKED) {
uiLayoutSetActive(layout, 0);
{0.f, 1.f, 0.f}};
- BKE_movieclip_acquire_size(clip, &sc->user, &size[0], &size[1]);
+ BKE_movieclip_get_size(clip, &sc->user, &size[0], &size[1]);
if(!size[0] || !size[1])
return;
if(sc->flag&SC_SHOW_STABLE) {
float smat[4][4], ismat[4][4];
- ibuf= ED_space_clip_acquire_stable_buffer(sc, sc->loc, &sc->scale, &sc->angle);
+ ibuf= ED_space_clip_get_stable_buffer(sc, sc->loc, &sc->scale, &sc->angle);
BKE_tracking_stabdata_to_mat4(width, height, sc->loc, sc->scale, sc->angle, sc->stabmat);
unit_m4(smat);
mul_serie_m4(sc->unistabmat, smat, sc->stabmat, ismat, NULL, NULL, NULL, NULL, NULL);
} else {
- ibuf= ED_space_clip_acquire_buffer(sc);
+ ibuf= ED_space_clip_get_buffer(sc);
zero_v2(sc->loc);
sc->scale= 1.f;
/* if manual calibration is used then grase pencil data is already
drawed in draw_distortion */
if((sc->flag&SC_MANUAL_CALIBRATION)==0 || sc->mode!=SC_MODE_DISTORTION) {
- ibuf= ED_space_clip_acquire_buffer(sc);
+ ibuf= ED_space_clip_get_buffer(sc);
if(ibuf) {
glPushMatrix();
return sc->clip;
}
-ImBuf *ED_space_clip_acquire_buffer(SpaceClip *sc)
+ImBuf *ED_space_clip_get_buffer(SpaceClip *sc)
{
if(sc->clip) {
ImBuf *ibuf;
- ibuf= BKE_movieclip_acquire_ibuf(sc->clip, &sc->user);
+ ibuf= BKE_movieclip_get_ibuf(sc->clip, &sc->user);
if(ibuf && (ibuf->rect || ibuf->rect_float))
return ibuf;
return NULL;
}
-ImBuf *ED_space_clip_acquire_stable_buffer(SpaceClip *sc, float loc[2], float *scale, float *angle)
+ImBuf *ED_space_clip_get_stable_buffer(SpaceClip *sc, float loc[2], float *scale, float *angle)
{
if(sc->clip) {
ImBuf *ibuf;
- ibuf= BKE_movieclip_acquire_stable_ibuf(sc->clip, &sc->user, loc, scale, angle);
+ ibuf= BKE_movieclip_get_stable_ibuf(sc->clip, &sc->user, loc, scale, angle);
if(ibuf && (ibuf->rect || ibuf->rect_float))
return ibuf;
*width= 0;
*height= 0;
} else
- BKE_movieclip_acquire_size(sc->clip, &sc->user, width, height);
+ BKE_movieclip_get_size(sc->clip, &sc->user, width, height);
}
void ED_space_clip_zoom(SpaceClip *sc, ARegion *ar, float *zoomx, float *zoomy)
ImBuf *tmpibuf= NULL;
if(clip && clip->tracking.stabilization.flag&TRACKING_2D_STABILIZATION) {
- tmpibuf= ED_space_clip_acquire_stable_buffer(sc, NULL, NULL, NULL);
+ tmpibuf= ED_space_clip_get_stable_buffer(sc, NULL, NULL, NULL);
}
ED_clip_view_selection(sc, ar, 0);
}
/* could fail if footage uses images with different sizes */
- BKE_movieclip_acquire_size(clip, NULL, &width, &height);
+ BKE_movieclip_get_size(clip, NULL, &width, &height);
error= BKE_tracking_solve_reconstruction(tracking, width, height);
MovieClip *clip= ED_space_clip(sc);
int width, height;
- BKE_movieclip_acquire_size(clip, &sc->user, &width, &height);
+ BKE_movieclip_get_size(clip, &sc->user, &width, &height);
if(width==0 || height==0)
return OPERATOR_CANCELLED;
{
SpaceClip *sc= CTX_wm_space_clip(C);
MovieClip *clip= ED_space_clip(sc);
- ImBuf *ibuf= BKE_movieclip_acquire_ibuf_flag(clip, &sc->user, 0);
+ ImBuf *ibuf= BKE_movieclip_get_ibuf_flag(clip, &sc->user, 0);
MovieTrackingTrack *track= clip->tracking.tracks.first;
int detector= RNA_enum_get(op->ptr, "detector");
int use_grease_pencil= RNA_boolean_get(op->ptr, "use_grease_pencil");
continue;
BKE_movieclip_user_set_frame(&bgpic->cuser, CFRA);
- ibuf= BKE_movieclip_acquire_ibuf(clip, &bgpic->cuser);
+ ibuf= BKE_movieclip_get_ibuf(clip, &bgpic->cuser);
/* working with ibuf from image and clip has got different workflow now.
ibuf acquired from clip is referenced by cache system and should
MovieClip *clip= (MovieClip*)ptr->id.data;
ImBuf *ibuf;
- ibuf= BKE_movieclip_acquire_ibuf(clip, NULL);
+ ibuf= BKE_movieclip_get_ibuf(clip, NULL);
if (ibuf) {
values[0]= ibuf->ppm[0];
values[1]= ibuf->ppm[1];
RNA_def_property_update(prop, NC_MOVIECLIP|ND_DISPLAY, "rna_MovieClip_reload_update");
}
-static void rna_def_moviecliUuser(BlenderRNA *brna)
+static void rna_def_moviecliUser(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
{
rna_def_movieclip(brna);
rna_def_movieclip_proxy(brna);
- rna_def_moviecliUuser(brna);
+ rna_def_moviecliUser(brna);
rna_def_movieClipScopes(brna);
}
float *rect;
int alloc= FALSE;
- ibuf= BKE_movieclip_acquire_ibuf(clip, user);
+ ibuf= BKE_movieclip_get_ibuf(clip, user);
if(ibuf==NULL || (ibuf->rect==NULL && ibuf->rect_float==NULL)) {
IMB_freeImBuf(ibuf);
ibuf->rect_float= cbuf->rect;
- BKE_movieclip_acquire_size(clip, NULL, &width, &height);
+ BKE_movieclip_get_size(clip, NULL, &width, &height);
if(!node->storage)
node->storage= BKE_tracking_distortion_create();