diff --git a/release/scripts/startup/bl_ui/space_clip.py b/release/scripts/startup/bl_ui/space_clip.py
index 52e0d460119..945b7d62766 100644
--- a/release/scripts/startup/bl_ui/space_clip.py
+++ b/release/scripts/startup/bl_ui/space_clip.py
@@ -66,11 +66,20 @@ class CLIP_PT_tools(bpy.types.Panel):
 
             col = layout.column(align=True)
             col.label(text="2D tracking:")
-            col.operator("clip.track_markers")
-            col.operator("clip.track_markers", text="Track Backwards").backwards=True
-            col.operator("clip.clear_track_path")
+            row = col.row(align=True)
+
+            op = row.operator("clip.track_markers", text="", icon='REW')
+            op.sequence = True
+            op.backwards = True
+            op = row.operator("clip.track_markers", text="", icon='PLAY_REVERSE')
+            op.backwards = True
+            row.operator("clip.track_markers", text="", icon='PLAY')
+            op = row.operator("clip.track_markers", text="", icon='FF')
+            op.sequence = True
+
+            layout.operator("clip.clear_track_path")
         else:
-          layout.operator('clip.open')
+            layout.operator('clip.open')
 
 
 class CLIP_PT_marker_preview(bpy.types.Panel):
diff --git a/source/blender/blenkernel/BKE_tracking.h b/source/blender/blenkernel/BKE_tracking.h
index 107348f093f..50f64b0486f 100644
--- a/source/blender/blenkernel/BKE_tracking.h
+++ b/source/blender/blenkernel/BKE_tracking.h
@@ -45,6 +45,7 @@ void BKE_tracking_clamp_track(struct MovieTrackingTrack *track, int event);
 void BKE_tracking_track_flag(struct MovieTrackingTrack *track, int area, int flag, int clear);
 void BKE_tracking_insert_marker(struct MovieTrackingTrack *track, struct MovieTrackingMarker *marker);
 struct MovieTrackingMarker *BKE_tracking_get_marker(struct MovieTrackingTrack *track, int framenr);
+struct MovieTrackingMarker *BKE_tracking_ensure_marker(struct MovieTrackingTrack *track, int framenr);
 int BKE_tracking_has_marker(struct MovieTrackingTrack *track, int framenr);
 
 void BKE_tracking_free_track(struct MovieTrackingTrack *track);
diff --git a/source/blender/blenkernel/intern/tracking.c b/source/blender/blenkernel/intern/tracking.c
index 2ac2f6b1b26..4da99163cda 100644
--- a/source/blender/blenkernel/intern/tracking.c
+++ b/source/blender/blenkernel/intern/tracking.c
@@ -150,7 +150,7 @@ void BKE_tracking_insert_marker(MovieTrackingTrack *track, MovieTrackingMarker *
 {
 	MovieTrackingMarker *old_marker= BKE_tracking_get_marker(track, marker->framenr);
 
-	if(old_marker) {
+	if(old_marker && old_marker->framenr==marker->framenr) {
 		*old_marker= *marker;
 	} else {
 		int a= track->markersnr;
@@ -167,6 +167,8 @@ void BKE_tracking_insert_marker(MovieTrackingTrack *track, MovieTrackingMarker *
 
 		memmove(track->markers+a+2, track->markers+a+1, (track->markersnr-a-2)*sizeof(MovieTrackingMarker));
 		track->markers[a+1]= *marker;
+
+		track->last_marker= a+1;
 	}
 }
 
@@ -177,39 +179,58 @@ MovieTrackingMarker *BKE_tracking_get_marker(MovieTrackingTrack *track, int fram
 	if(!track->markersnr)
 		return NULL;
 
-	if((track->flag&TRACK_PROCESSED)==0) {
-		/* non-precessed tracks contains the only marker
-		   which should be used independelntly from current frame number. */
-
-		if(track->markersnr)
-			return &track->markers[0];
-
-		return NULL;
-	}
+	/* approximate pre-first framenr marker with first marker */
+	if(framenr<track->markers[0].framenr)
+		return &track->markers[0];
 
 	if(track->last_marker<track->markersnr)
 		a= track->last_marker;
 
 	if(track->markers[a].framenr<=framenr) {
-		while(a<track->markersnr) {
+		while(a<track->markersnr && track->markers[a].framenr<=framenr) {
 			if(track->markers[a].framenr==framenr) {
 				track->last_marker= a;
 				return &track->markers[a];
 			}
 			a++;
 		}
+
+		/* if there's no marker for exact position, use nearest marker from left side */
+		return &track->markers[a-1];
 	} else {
-		while(a--) {
+		while(a>=0 && track->markers[a].framenr>=framenr) {
 			if(track->markers[a].framenr==framenr) {
 				track->last_marker= a;
 				return &track->markers[a];
 			}
+
+			a--;
 		}
+
+		/* if there's no marker for exact position, use nearest marker from left side */
+		return &track->markers[a];
 	}
 
 	return NULL;
 }
 
+MovieTrackingMarker *BKE_tracking_ensure_marker(MovieTrackingTrack *track, int framenr)
+{
+	MovieTrackingMarker *marker= BKE_tracking_get_marker(track, framenr);
+
+	if(marker && marker->framenr!=framenr) {
+		MovieTrackingMarker marker_new;
+
+		marker_new= *marker;
+		marker_new.framenr= framenr;
+
+		BKE_tracking_insert_marker(track, &marker_new);
+		marker= BKE_tracking_get_marker(track, framenr);
+	}
+
+	return marker;
+}
+
 int BKE_tracking_has_marker(MovieTrackingTrack *track, int framenr)
 {
 	return BKE_tracking_get_marker(track, framenr) != 0;
@@ -515,7 +536,7 @@ int BKE_tracking_next(MovieTrackingContext *context)
 	while(track) {
 		MovieTrackingMarker *marker= BKE_tracking_get_marker(track, curfra);
 
-		if(marker) {
+		if(marker && marker->framenr==curfra) {
 #ifdef WITH_LIBMV
 			int width, height, pos[2];
 			float *patch= acquire_search_floatbuf(ibuf, track, marker, &width, &height, pos);
@@ -533,17 +554,13 @@ int BKE_tracking_next(MovieTrackingContext *context)
 						x1, y1, &x2, &y2)) {
 				MovieTrackingMarker marker_new;
 
+				memset(&marker_new, 0, sizeof(marker_new));
 				marker_new.pos[0]= marker->pos[0]+track->search_min[0]+x2/ibuf_new->x;
 				marker_new.pos[1]= marker->pos[1]+track->search_min[1]+y2/ibuf_new->y;
 
 				if(context->backwards) marker_new.framenr= curfra-1;
 				else marker_new.framenr= curfra+1;
 
-				/* happens when current frame was changed after placing marker
-				   but before tracking it */
-				if(marker->framenr!=curfra)
-					marker->framenr= curfra;
-
 				track->flag|= TRACK_PROCESSED;
 
 				BKE_tracking_insert_marker(track, &marker_new);
diff --git a/source/blender/editors/space_clip/clip_buttons.c b/source/blender/editors/space_clip/clip_buttons.c
index 88c919e03a7..deeaf25d232 100644
--- a/source/blender/editors/space_clip/clip_buttons.c
+++ b/source/blender/editors/space_clip/clip_buttons.c
@@ -66,6 +66,7 @@
 #define B_MARKER_PAT_DIM		5
 #define B_MARKER_SEARCH_POS		6
 #define B_MARKER_SEARCH_DIM		7
+#define B_MARKER_FLAG			8
 
 static void to_pixel_space(float r[2], float a[2], int width, int height)
 {
@@ -74,7 +75,7 @@ static void to_pixel_space(float r[2], float a[2], int width, int height)
 	r[1]*= height;
 }
 
-static void trackingMarker_buttons(const bContext *C, uiBlock *block)
+static void trackingMarker_buttons(const bContext *C, uiLayout *layout)
 {
 	SpaceClip *sc= CTX_wm_space_clip(C);
 	MovieClip *clip= ED_space_clip(sc);
@@ -82,6 +83,8 @@ static void trackingMarker_buttons(const bContext *C, uiBlock *block)
 	MovieTrackingTrack *track;
 	MovieTrackingMarker *marker;
 	float pat_dim[2], pat_pos[2], search_dim[2], search_pos[2];
+	uiBlock *block;
+	uiLayout *col;
 
 	ED_space_clip_size(sc, &width, &height);
 	BKE_movieclip_last_selection(clip, &type, (void**)&track);
@@ -106,6 +109,17 @@ static void trackingMarker_buttons(const bContext *C, uiBlock *block)
 	to_pixel_space(sc->track_search, search_dim, width, height);
 	to_pixel_space(sc->track_search_pos, search_pos, width, height);
 
+	sc->marker_flag= marker->flag;
+
+	block= uiLayoutAbsoluteBlock(layout);
+
+	uiDefButBitI(block, OPTION, MARKER_DISABLED, B_MARKER_FLAG,  "Disabled", 10, 190, 145, 19, &sc->marker_flag,
+		0, 0, 0, 0, "Marker is disabled for current frame.");
+
+	col= uiLayoutColumn(layout, 1);
+	uiLayoutSetActive(col, (sc->marker_flag&MARKER_DISABLED)==0);
+
+	block= uiLayoutAbsoluteBlock(col);
 	uiBlockBeginAlign(block);
 
 	uiDefBut(block, LABEL, 0, "Position:", 0, 171, 145, 19, NULL, 0, 0, 0, 0, "");
@@ -133,6 +147,7 @@ static void trackingMarker_buttons(const bContext *C, uiBlock *block)
 		10.0*width, step, digits, "Width of marker's search in screen soordinates.");
 	uiDefButF(block, NUM, B_MARKER_SEARCH_DIM, "Height:", 10, 0, 300, 19, &sc->track_search[1], 3.0f,
 		10.0*height, step, digits, "Height of marker's search in screen soordinates.");
+
 	uiBlockEndAlign(block);
 }
 
@@ -147,7 +162,8 @@ static void do_tracking_marker(bContext *C, void *UNUSED(arg), int event)
 	ED_space_clip_size(sc, &width, &height);
 
 	BKE_movieclip_last_selection(clip, &type, (void**)&track);
-	marker= BKE_tracking_get_marker(track, sc->user.framenr);
+
+	marker= BKE_tracking_ensure_marker(track, sc->user.framenr);
 
 	if(event==B_MARKER_POS) {
 		marker->pos[0]= sc->marker_pos[0]/width;
@@ -211,6 +227,10 @@ static void do_tracking_marker(bContext *C, void *UNUSED(arg), int event)
 
 		BKE_tracking_clamp_track(track, CLAMP_SEARCH_DIM);
 
+		ok= 1;
+	} else if(event==B_MARKER_FLAG) {
+		marker->flag= sc->marker_flag;
+
 		ok= 1;
 	}
 
@@ -222,7 +242,6 @@ static void do_tracking_marker(bContext *C, void *UNUSED(arg), int event)
 
 static int clip_panel_marker_poll(const bContext *C, PanelType *UNUSED(pt))
 {
-	Scene *scene= CTX_data_scene(C);
 	SpaceClip *sc= CTX_wm_space_clip(C);
 	MovieClip *clip;
 	int type;
@@ -251,7 +270,7 @@ static void clip_panel_marker(const bContext *C, Panel *pa)
 	block= uiLayoutAbsoluteBlock(pa->layout);
 	uiBlockSetHandleFunc(block, do_tracking_marker, NULL);
 
-	trackingMarker_buttons(C, block);
+	trackingMarker_buttons(C, pa->layout);
 }
 
 void ED_clip_buttons_register(ARegionType *art)
diff --git a/source/blender/editors/space_clip/clip_draw.c b/source/blender/editors/space_clip/clip_draw.c
index 6a3505688b9..199080895c8 100644
--- a/source/blender/editors/space_clip/clip_draw.c
+++ b/source/blender/editors/space_clip/clip_draw.c
@@ -69,14 +69,18 @@
 static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Scene *scene)
 {
 	float x;
-	int *points, totseg;
+	int *points, totseg, sel_type;
 	float sfra= SFRA, efra= EFRA;
+	void *sel;
+	float framelen= ar->winx/(efra-sfra+1);
+
+	BKE_movieclip_last_selection(clip, &sel_type, &sel);
 
 	glEnable(GL_BLEND);
 
 	/* cache background */
 	glColor4ub(128, 128, 255, 64);
-	glRecti(0, 0, ar->winx, 5);
+	glRecti(0, 0, ar->winx, 8);
 
 	/* cached segments -- could be usefu lto debug caching strategies */
 	BKE_movieclip_get_cache_segments(clip, &totseg, &points);
@@ -91,7 +95,40 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
 			x1= (points[a*2]-sfra)/(efra-sfra+1)*ar->winx;
 			x2= (points[a*2+1]-sfra+1)/(efra-sfra+1)*ar->winx;
 
-			glRecti(x1, 0, x2, 5);
+			glRecti(x1, 0, x2, 8);
+		}
+	}
+
+	/* track */
+	if(sel_type==MCLIP_SEL_TRACK) {
+		int i, a= 0;
+		MovieTrackingTrack *track= (MovieTrackingTrack *)sel;
+
+		for(i= sfra; i <= efra; i++) {
+			int framenr;
+			MovieTrackingMarker *marker;
+
+			while(a<track->markersnr) {
+				if(track->markers[a].framenr>=i)
+					break;
+
+				if(a<track->markersnr-1 && track->markers[a+1].framenr>i)
+					break;
+
+				a++;
+			}
+
+			if(a<track->markersnr) marker= &track->markers[a];
+			else marker= &track->markers[track->markersnr-1];
+
+			if((marker->flag&MARKER_DISABLED)==0) {
+				framenr= marker->framenr;
+
+				if(framenr!=i) glColor4ub(128, 128, 0, 96);
+				else glColor4ub(255, 255, 0, 96);
+
+				glRecti((i-1)*framelen, 0, i*framelen, 4);
+			}
 		}
 	}
 
@@ -101,15 +138,15 @@ static void draw_movieclip_cache(SpaceClip *sc, ARegion *ar, MovieClip *clip, Sc
 	x= (sc->user.framenr-sfra)/(efra-sfra+1)*ar->winx;
 
 	UI_ThemeColor(TH_CFRAME);
-	glRecti(x, 0, x+ar->winx/(efra-sfra), 5);
+	glRecti(x, 0, x+framelen, 8);
 }
 
-static void draw_movieclip_buffer(SpaceClip *sc, ARegion *ar, ImBuf *ibuf)
+static void draw_movieclip_buffer(ARegion *ar, ImBuf *ibuf, float zoomx, float zoomy)
 {
 	int x, y;
 
 	/* set zoom */
-	glPixelZoom(sc->zoom, sc->zoom);
+	glPixelZoom(zoomx, zoomy);
 
 	/* find window pixel coordinates of origin */
 	UI_view2d_to_region_no_clip(&ar->v2d, 0.f, 0.f, &x, &y);
@@ -129,7 +166,7 @@ static void draw_track_path(SpaceClip *sc, MovieClip *clip, MovieTrackingTrack *
 	int count= sc->path_length;
 	int i, a, b, sel_type, curindex= -1;
 	float path[102][2];
-	int tiny= sc->flag&SC_SHOW_TINY_MARKER;
+	int tiny= sc->flag&SC_SHOW_TINY_MARKER, framenr;
 	MovieTrackingMarker *marker;
 	void *sel;
 
@@ -142,37 +179,44 @@ static void draw_track_path(SpaceClip *sc, MovieClip *clip, MovieTrackingTrack *
 	if((track->flag&TRACK_PROCESSED)==0)
 		return;
 
-	if(!BKE_tracking_has_marker(track, sc->user.framenr))
+	marker= BKE_tracking_get_marker(track, sc->user.framenr);
+	if(marker==NULL || marker->flag&MARKER_DISABLED)
 		return;
 
+	framenr= marker->framenr;
+
 	a= count;
-	i= sc->user.framenr-1;
-	while(i>=sc->user.framenr-count) {
+	i= framenr-1;
+	while(i>=framenr-count) {
 		marker= BKE_tracking_get_marker(track, i);
 
-		if(!marker)
+		if(!marker || marker->flag&MARKER_DISABLED)
 			break;
 
-		copy_v2_v2(path[--a], marker->pos);
+		if(marker->framenr==i) {
+			copy_v2_v2(path[--a], marker->pos);
 
-		if(marker->framenr==sc->user.framenr)
-			curindex= a;
+			if(marker->framenr==sc->user.framenr)
+				curindex= a;
+		}
 
 		i--;
 	}
 
 	b= count;
-	i= sc->user.framenr;
-	while(i<=sc->user.framenr+count) {
+	i= framenr;
+	while(i<=framenr+count) {
 		marker= BKE_tracking_get_marker(track, i);
 
-		if(!marker)
+		if(!marker || marker->flag&MARKER_DISABLED)
 			break;
 
-		if(marker->framenr==sc->user.framenr)
-			curindex= b;
+		if(marker->framenr==i) {
+			if(marker->framenr==sc->user.framenr)
+				curindex= b;
 
-		copy_v2_v2(path[b++], marker->pos);
+			copy_v2_v2(path[b++], marker->pos);
+		}
 
 		i++;
 	}
@@ -226,12 +270,15 @@ static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieT
 	int tiny= sc->flag&SC_SHOW_TINY_MARKER;
 
 	UI_ThemeColor(TH_MARKER_OUTLINE);
-	if(tiny) glPointSize(3.0f);
-	else glPointSize(4.0f);
-	glBegin(GL_POINTS);
-		glVertex2f(marker->pos[0], marker->pos[1]);
-	glEnd();
-	glPointSize(1.0f);
+
+	if((marker->flag&MARKER_DISABLED)==0) {
+		if(tiny) glPointSize(3.0f);
+		else glPointSize(4.0f);
+		glBegin(GL_POINTS);
+			glVertex2f(marker->pos[0], marker->pos[1]);
+		glEnd();
+		glPointSize(1.0f);
+	}
 
 	/* pattern and search outline */
 	glPushMatrix();
@@ -239,7 +286,7 @@ static void draw_marker_outline(SpaceClip *sc, MovieTrackingTrack *track, MovieT
 
 	if(!tiny) glLineWidth(3.0f);
 
-	if(sc->flag&SC_SHOW_MARKER_PATTERN) {
+	if(sc->flag&SC_SHOW_MARKER_PATTERN && (marker->flag&MARKER_DISABLED)==0) {
 		glBegin(GL_LINE_LOOP);
 			glVertex2f(track->pat_min[0], track->pat_min[1]);
 			glVertex2f(track->pat_max[0], track->pat_min[1]);
@@ -267,7 +314,7 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 	int tiny= sc->flag&SC_SHOW_TINY_MARKER;
 
 	/* marker position */
-	if((track->flag&SELECT)==sel) {
+	if((track->flag&SELECT)==sel && (marker->flag&MARKER_DISABLED)==0) {
 		if(track->flag&SELECT) UI_ThemeColor(color);
 		else UI_ThemeColor(TH_MARKER);
 
@@ -287,7 +334,7 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 	glPushMatrix();
 	glTranslatef(marker->pos[0], marker->pos[1], 0);
 
-	if((track->pat_flag&SELECT)==sel) {
+	if((track->pat_flag&SELECT)==sel && (marker->flag&MARKER_DISABLED)==0) {
 		if(track->pat_flag&SELECT) UI_ThemeColor(color);
 		else UI_ThemeColor(TH_MARKER);
 
@@ -322,9 +369,20 @@ static void draw_marker_areas(SpaceClip *sc, MovieTrackingTrack *track, MovieTra
 		glDisable(GL_LINE_STIPPLE);
 }
 
-static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip)
+static void view2d_to_region_float(View2D *v2d, float x, float y, float *regionx, float *regiony)
 {
-	int x, y;
+	/* express given coordinates as proportional values */
+	x= -v2d->cur.xmin / (v2d->cur.xmax-v2d->cur.xmin);
+	y= -v2d->cur.ymin / (v2d->cur.ymax-v2d->cur.ymin);
+
+	/* convert proportional distances to screen coordinates */
+	*regionx= v2d->mask.xmin + x*(v2d->mask.xmax-v2d->mask.xmin);
+	*regiony= v2d->mask.ymin + y*(v2d->mask.ymax-v2d->mask.ymin);
+}
+
+static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip, float zoomx, float zoomy)
+{
+	float x, y;
 	MovieTrackingMarker *marker;
 	MovieTrackingTrack *track;
 	int width, height, sel_type;
@@ -335,12 +393,18 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip)
 	if(!width || !height) /* no image displayed for frame */
 		return;
 
-	/* find window pixel coordinates of origin */
-	UI_view2d_to_region_no_clip(&ar->v2d, 0.0f, 0.0f, &x, &y);
+	/* ** find window pixel coordinates of origin ** */
+
+	/* UI_view2d_to_region_no_clip return integer values, this could
+	   lead to 1px flickering when view is locked to selection during playbeck.
+	   to avoid this flickering, calclate base point in the same way as it happens
+	   in UI_view2d_to_region_no_clip, but do it in floats here */
+
+	view2d_to_region_float(&ar->v2d, 0.0f, 0.0f, &x, &y);
 
 	glPushMatrix();
 	glTranslatef(x, y, 0);
-	glScalef(sc->zoom, sc->zoom, 0);
+	glScalef(zoomx, zoomy, 0);
 	glScalef(width, height, 0);
 
 	BKE_movieclip_last_selection(clip, &sel_type, &sel);
@@ -392,32 +456,30 @@ static void draw_tracking_tracks(SpaceClip *sc, ARegion *ar, MovieClip *clip)
 	glPopMatrix();
 }
 
-static void draw_tracking(SpaceClip *sc, ARegion *ar, MovieClip *clip)
+static void draw_tracking(SpaceClip *sc, ARegion *ar, MovieClip *clip, float zoomx, float zoomy)
 {
-	draw_tracking_tracks(sc, ar, clip);
+	draw_tracking_tracks(sc, ar, clip, zoomx, zoomy);
 }
 
 void draw_clip_main(SpaceClip *sc, ARegion *ar, Scene *scene)
 {
 	MovieClip *clip= ED_space_clip(sc);
 	ImBuf *ibuf;
+	float zoomx, zoomy;
 
 	/* if no clip, nothing to do */
 	if(!clip)
 		return;
 
-	/* if trcking is in progress, we should sunchronize framenr from clipuser
-	   so latest tracked frame would be shown */
-	if(clip->tracking_context)
-		BKE_tracking_sync_user(&sc->user, clip->tracking_context);
+	ED_space_clip_zoom(sc, ar, &zoomx, &zoomy);
 
 	ibuf= ED_space_clip_acquire_buffer(sc);
 
 	if(ibuf) {
-		draw_movieclip_buffer(sc, ar, ibuf);
+		draw_movieclip_buffer(ar, ibuf, zoomx, zoomy);
 		IMB_freeImBuf(ibuf);
 
-		draw_tracking(sc, ar, clip);
+		draw_tracking(sc, ar, clip, zoomx, zoomy);
 	}
 
 	if(sc->debug_flag&SC_DBG_SHOW_CACHE)
@@ -438,7 +500,14 @@ void draw_clip_track_widget(const bContext *C, void *trackp, void *userp, void *
 	if(track) {
 		MovieTrackingMarker *marker= BKE_tracking_get_marker(track, user->framenr);
 
-		if(marker) {
+		if(marker && marker->flag&MARKER_DISABLED) {
+			glColor4f(0.7f, 0.3f, 0.3f, 0.3f);
+			uiSetRoundBox(15);
+			uiDrawBox(GL_POLYGON, rect->xmin, rect->ymin, rect->xmax, rect->ymax, 3.0f);
+
+			ok= 1;
+		}
+		else if(marker) {
 			ImBuf* ibuf= BKE_movieclip_acquire_ibuf(clip, user);
 
 			if(ibuf && ibuf->rect) {
diff --git a/source/blender/editors/space_clip/space_clip.c b/source/blender/editors/space_clip/space_clip.c
index de0a878e946..433e06a043e 100644
--- a/source/blender/editors/space_clip/space_clip.c
+++ b/source/blender/editors/space_clip/space_clip.c
@@ -46,6 +46,7 @@
 #include "BKE_context.h"
 #include "BKE_screen.h"
 #include "BKE_movieclip.h"
+#include "BKE_tracking.h"
 
 #include "IMB_imbuf_types.h"
 
@@ -259,9 +260,14 @@ static void clip_keymap(struct wmKeyConfig *keyconf)
 
 	WM_keymap_add_item(keymap, "CLIP_OT_add_marker", LEFTMOUSE, KM_PRESS, KM_CTRL, 0);
 
-	WM_keymap_add_item(keymap, "CLIP_OT_track_markers", TKEY, KM_PRESS, KM_CTRL, 0);
+	kmi= WM_keymap_add_item(keymap, "CLIP_OT_track_markers", LEFTARROWKEY, KM_PRESS, KM_ALT, 0);
+	RNA_boolean_set(kmi->ptr, "backwards", 1);
+	WM_keymap_add_item(keymap, "CLIP_OT_track_markers", RIGHTARROWKEY, KM_PRESS, KM_ALT, 0);
+	kmi= WM_keymap_add_item(keymap, "CLIP_OT_track_markers", TKEY, KM_PRESS, KM_CTRL, 0);
+	RNA_boolean_set(kmi->ptr, "sequence", 1);
 	kmi= WM_keymap_add_item(keymap, "CLIP_OT_track_markers", TKEY, KM_PRESS, KM_SHIFT|KM_CTRL, 0);
 	RNA_boolean_set(kmi->ptr, "backwards", 1);
+	RNA_boolean_set(kmi->ptr, "sequence", 1);
 	WM_keymap_add_item(keymap, "CLIP_OT_clear_track_path", TKEY, KM_PRESS, KM_ALT, 0);
 
 	WM_keymap_add_item(keymap, "CLIP_OT_delete", XKEY, KM_PRESS, 0, 0);
@@ -359,6 +365,12 @@ static void clip_main_area_draw(const bContext *C, ARegion *ar)
 	/* draw entirely, view changes should be handled here */
 	SpaceClip *sc= CTX_wm_space_clip(C);
 	Scene *scene= CTX_data_scene(C);
+	MovieClip *clip= ED_space_clip(sc);
+
+	/* if trcking is in progress, we should sunchronize framenr from clipuser
+	   so latest tracked frame would be shown */
+	if(clip->tracking_context)
+		BKE_tracking_sync_user(&sc->user, clip->tracking_context);
 
 	if(sc->flag&SC_LOCK_SELECTION)
 		ED_clip_view_selection(sc, ar, 0);
diff --git a/source/blender/editors/space_clip/tracking_ops.c b/source/blender/editors/space_clip/tracking_ops.c
index c66839e42da..23def20f02b 100644
--- a/source/blender/editors/space_clip/tracking_ops.c
+++ b/source/blender/editors/space_clip/tracking_ops.c
@@ -116,6 +116,7 @@ static void add_marker(SpaceClip *sc, float x, float y)
 
 	track= MEM_callocN(sizeof(MovieTrackingTrack), "add_marker_exec track");
 
+	memset(&marker, 0, sizeof(marker));
 	marker.pos[0]= x;
 	marker.pos[1]= y;
 	marker.framenr= sc->user.framenr;
@@ -279,12 +280,14 @@ static int track_mouse_area(SpaceClip *sc, float co[2], MovieTrackingTrack *trac
 	epsx= MAX2(epsy, 2.0 / width);
 	epsy= MAX2(epsy, 2.0 / height);
 
-	if(fabsf(co[0]-marker->pos[0])< epsx && fabsf(co[1]-marker->pos[1])<=epsy)
-		return TRACK_AREA_POINT;
+	if((marker->flag&MARKER_DISABLED)==0) {
+		if(fabsf(co[0]-marker->pos[0])< epsx && fabsf(co[1]-marker->pos[1])<=epsy)
+			return TRACK_AREA_POINT;
 
-	if(sc->flag&SC_SHOW_MARKER_PATTERN)
-		if(mouse_on_rect(co, marker->pos, track->pat_min, track->pat_max, epsx, epsy))
-			return TRACK_AREA_PAT;
+		if(sc->flag&SC_SHOW_MARKER_PATTERN)
+			if(mouse_on_rect(co, marker->pos, track->pat_min, track->pat_max, epsx, epsy))
+				return TRACK_AREA_PAT;
+	}
 
 	if(sc->flag&SC_SHOW_MARKER_SEARCH)
 		if(mouse_on_rect(co, marker->pos, track->search_min, track->search_max, epsx, epsy))
@@ -673,6 +676,19 @@ static int track_markers_testbreak(void)
 	return G.afbreek;
 }
 
+static void track_init_markers(SpaceClip *sc, MovieClip *clip)
+{
+	MovieTrackingTrack *track;
+	int framenr= sc->user.framenr;
+
+	track= clip->tracking.tracks.first;
+	while(track) {
+		BKE_tracking_ensure_marker(track, framenr);
+
+		track= track->next;
+	}
+}
+
 static void track_markers_initjob(bContext *C, TrackMarkersJob *tmj, int backwards)
 {
 	SpaceClip *sc= CTX_wm_space_clip(C);
@@ -700,6 +716,8 @@ static void track_markers_initjob(bContext *C, TrackMarkersJob *tmj, int backwar
 		else if(settings->speed==TRACKING_SPEED_QUARTER) tmj->delay*= 4;
 	}
 
+	track_init_markers(sc, clip);
+
 	tmj->context= BKE_tracking_context_new(clip, &sc->user, backwards);
 
 	clip->tracking_context= tmj->context;
@@ -776,6 +794,54 @@ static void track_markers_freejob(void *tmv)
 	WM_main_add_notifier(NC_SCENE|ND_FRAME, tmj->scene);
 }
 
+static int track_markers_exec(bContext *C, wmOperator *op)
+{
+	SpaceClip *sc= CTX_wm_space_clip(C);
+	MovieClip *clip= ED_space_clip(sc);
+	Scene *scene= CTX_data_scene(C);
+	struct MovieTrackingContext *context;
+	int framenr= sc->user.framenr;
+	int sfra= framenr, efra;
+	int backwards= RNA_boolean_get(op->ptr, "backwards");
+	int sequence= RNA_boolean_get(op->ptr, "sequence");
+	MovieTrackingSettings *settings= &clip->tracking.settings;
+
+	if(backwards) efra= SFRA;
+	else efra= EFRA;
+
+	/* limit frames to be tracked by user setting */
+	if(settings->flag&TRACKING_FRAMES_LIMIT) {
+		if(backwards) efra= MAX2(efra, sfra-settings->frames_limit);
+		else efra= MIN2(efra, sfra+settings->frames_limit);
+	}
+
+	track_init_markers(sc, clip);
+
+	context= BKE_tracking_context_new(clip, &sc->user, backwards);
+
+	while(framenr != efra) {
+		if(!BKE_tracking_next(context))
+			break;
+
+		if(backwards) framenr--;
+		else framenr++;
+
+		if(!sequence)
+			break;
+	}
+
+	BKE_tracking_sync(context);
+	BKE_tracking_context_free(context);
+
+	/* update scene current frame to the lastes tracked frame */
+	scene->r.cfra= framenr;
+
+	WM_event_add_notifier(C, NC_MOVIECLIP|NA_EVALUATED, clip);
+	WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
+
+	return OPERATOR_FINISHED;
+}
+
 static int track_markers_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
 {
 	TrackMarkersJob *tmj;
@@ -784,10 +850,14 @@ static int track_markers_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(eve
 	wmJob *steve;
 	Scene *scene= CTX_data_scene(C);
 	int backwards= RNA_boolean_get(op->ptr, "backwards");
+	int sequence= RNA_boolean_get(op->ptr, "sequence");
 
 	if(clip->tracking_context)
 		return OPERATOR_CANCELLED;
 
+	if(!sequence)
+		return track_markers_exec(C, op);
+
 	tmj= MEM_callocN(sizeof(TrackMarkersJob), "TrackMarkersJob data");
 	track_markers_initjob(C, tmj, backwards);
 
@@ -815,48 +885,6 @@ static int track_markers_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(eve
 	return OPERATOR_RUNNING_MODAL;
 }
 
-static int track_markers_exec(bContext *C, wmOperator *op)
-{
-	SpaceClip *sc= CTX_wm_space_clip(C);
-	MovieClip *clip= ED_space_clip(sc);
-	Scene *scene= CTX_data_scene(C);
-	struct MovieTrackingContext *context;
-	int framenr= sc->user.framenr;
-	int sfra= framenr, efra;
-	int backwards= RNA_boolean_get(op->ptr, "backwards");
-	MovieTrackingSettings *settings= &clip->tracking.settings;
-
-	if(backwards) efra= SFRA;
-	else efra= EFRA;
-
-	/* limit frames to be tracked by user setting */
-	if(settings->flag&TRACKING_FRAMES_LIMIT) {
-		if(backwards) efra= MAX2(efra, sfra-settings->frames_limit);
-		else efra= MIN2(efra, sfra+settings->frames_limit);
-	}
-
-	context= BKE_tracking_context_new(clip, &sc->user, backwards);
-
-	while(framenr != efra) {
-		if(!BKE_tracking_next(context))
-			break;
-
-		if(backwards) framenr--;
-		else framenr++;
-	}
-
-	BKE_tracking_sync(context);
-	BKE_tracking_context_free(context);
-
-	/* update scene current frame to the lastes tracked frame */
-	scene->r.cfra= framenr;
-
-	WM_event_add_notifier(C, NC_MOVIECLIP|NA_EVALUATED, clip);
-	WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
-
-	return OPERATOR_FINISHED;
-}
-
 static int track_marekrs_modal(bContext *C, wmOperator *UNUSED(op), wmEvent *event)
 {
 	/* no running blender, remove handler and pass through */
@@ -891,6 +919,7 @@ void CLIP_OT_track_markers(wmOperatorType *ot)
 
 	/* properties */
 	RNA_def_boolean(ot->srna, "backwards", 0, "Backwards", "Do backwards tarcking");
+	RNA_def_boolean(ot->srna, "sequence", 0, "Track Sequence", "Track marker during image sequence rather than single image");
 }
 
 /********************** clear track operator *********************/
@@ -988,14 +1017,12 @@ static int track_to_fcurves_exec(bContext *C, wmOperator *op)
 	kflag= ks->flag;
 	kflag |= ANIM_get_keyframing_flags(scene, 1);
 
-	(void)op;
-
 	BKE_movieclip_acquire_size(clip, &user, &width, &height);
 
 	while(fra<EFRA) {
 		MovieTrackingMarker *marker= BKE_tracking_get_marker(track, fra);
 
-		if(marker) {
+		if(marker && (marker->framenr&MARKER_DISABLED)==0) {
 			FCurve *fcu;
 
 			fcu= verify_fcurve(act, ks->name, "location", 0, 1);
diff --git a/source/blender/editors/transform/transform_conversions.c b/source/blender/editors/transform/transform_conversions.c
index 14a39b4ece4..01a398c40af 100644
--- a/source/blender/editors/transform/transform_conversions.c
+++ b/source/blender/editors/transform/transform_conversions.c
@@ -5243,17 +5243,26 @@ static void markerToTransDataInit(TransData *td, TransData2D *td2d, float *loc,
 
 static void trackToTransData(SpaceClip *sc, TransData *td, TransData2D *td2d, MovieTrackingTrack *track)
 {
-	MovieTrackingMarker *marker= BKE_tracking_get_marker(track, sc->user.framenr);
+	MovieTrackingMarker *marker= BKE_tracking_ensure_marker(track, sc->user.framenr);
 
-	if(track->flag&SELECT)
-		markerToTransDataInit(td++, td2d++, marker->pos, NULL);
+	if((marker->flag&MARKER_DISABLED)==0) {
+		if(track->flag&SELECT)
+			markerToTransDataInit(td++, td2d++, marker->pos, NULL);
 
-	if(track->pat_flag&SELECT) {
-		markerToTransDataInit(td++, td2d++, track->pat_min, marker->pos);
-		markerToTransDataInit(td++, td2d++, track->pat_max, marker->pos);
+		if(track->pat_flag&SELECT) {
+			markerToTransDataInit(td++, td2d++, track->pat_min, marker->pos);
+			markerToTransDataInit(td++, td2d++, track->pat_max, marker->pos);
+		}
 	}
 
 	if(track->search_flag&SELECT) {
+		if(marker->flag&MARKER_DISABLED) {
+			markerToTransDataInit(td++, td2d++, marker->pos, NULL);
+
+			markerToTransDataInit(td++, td2d++, track->pat_min, marker->pos);
+			markerToTransDataInit(td++, td2d++, track->pat_max, marker->pos);
+		}
+
 		markerToTransDataInit(td++, td2d++, track->search_min, marker->pos);
 		markerToTransDataInit(td++, td2d++, track->search_max, marker->pos);
 	}
@@ -5266,6 +5275,7 @@ static void createTransTrackingData(bContext *C, TransInfo *t)
 	SpaceClip *sc = CTX_wm_space_clip(C);
 	MovieClip *clip = ED_space_clip(sc);
 	MovieTrackingTrack *track;
+	MovieTrackingMarker *marker;
 	int framenr = sc->user.framenr;
 
 	if(clip && !BKE_movieclip_has_frame(clip, &sc->user)) {
@@ -5278,10 +5288,22 @@ static void createTransTrackingData(bContext *C, TransInfo *t)
 
 	track = clip->tracking.tracks.first;
 	while(track) {
-		if(BKE_tracking_has_marker(track, framenr)) {
-			if(track->flag&SELECT) t->total++;
-			if(track->pat_flag&SELECT) t->total+= 2;
-			if(track->search_flag&SELECT) t->total+= 2;
+		if(TRACK_SELECTED(track)) {
+			marker= BKE_tracking_get_marker(track, framenr);
+
+			if(marker) {
+				if((marker->flag&MARKER_DISABLED)==0) {
+					if(track->flag&SELECT) t->total++;
+					if(track->pat_flag&SELECT) t->total+= 2;
+				}
+
+				if(track->search_flag&SELECT) {
+					t->total+= 2;
+
+					if(marker->flag&MARKER_DISABLED)
+						t->total+= 3;
+				}
+			}
 		}
 
 		track = track->next;
@@ -5293,12 +5315,27 @@ static void createTransTrackingData(bContext *C, TransInfo *t)
 	/* create actual data */
 	track = clip->tracking.tracks.first;
 	while(track) {
-		if(TRACK_SELECTED(track) && BKE_tracking_has_marker(track, framenr)) {
-			trackToTransData(sc, td, td2d, track);
+		if(TRACK_SELECTED(track)) {
+			marker= BKE_tracking_get_marker(track, framenr);
 
-			if(track->flag&SELECT) {td++; td2d++;}
-			if(track->pat_flag&SELECT) {td+= 2; td2d+= 2;}
-			if(track->search_flag&SELECT) {td+= 2; td2d+= 2;};
+			if(marker) {
+				trackToTransData(sc, td, td2d, track);
+
+				if((marker->flag&MARKER_DISABLED)==0) {
+					if(track->flag&SELECT) {td++; td2d++;}
+					if(track->pat_flag&SELECT) {td+= 2; td2d+= 2;}
+				}
+
+				if(track->search_flag&SELECT) {
+					td+= 2;
+					td2d+= 2;
+
+					if(marker->flag&MARKER_DISABLED) {
+						td+= 3;
+						td2d+= 3;
+					}
+				};
+			}
 		}
 
 		track = track->next;
diff --git a/source/blender/makesdna/DNA_space_types.h b/source/blender/makesdna/DNA_space_types.h
index da4e60f18b6..4844ded5743 100644
--- a/source/blender/makesdna/DNA_space_types.h
+++ b/source/blender/makesdna/DNA_space_types.h
@@ -580,13 +580,12 @@ typedef struct SpaceClip {
 
 	int path_length;			/* length of displaying path, in frames */
 
-	int pad;
-
 	/* ** some runtime vars which aren't really in file ** */
 	/* marker data displayed in panel */
 	float marker_pos[2];						/* position of marker in pixel coords */
 	float track_pat_pos[2], track_pat[2];		/* position and dimensions of marker pattern in pixel coords */
 	float track_search_pos[2], track_search[2];	/* position and dimensions of marker search in pixel coords */
+	int marker_flag;							/* marker's flags */
 } SpaceClip;
 
 /* view3d  Now in DNA_view3d_types.h */
diff --git a/source/blender/makesdna/DNA_tracking_types.h b/source/blender/makesdna/DNA_tracking_types.h
index 15622414814..f3540150cbb 100644
--- a/source/blender/makesdna/DNA_tracking_types.h
+++ b/source/blender/makesdna/DNA_tracking_types.h
@@ -55,6 +55,7 @@ typedef struct MovieTrackingCamera {
 typedef struct MovieTrackingMarker {
 	float pos[2];	/* 2d position of marker on frame (in unified 0..1 space) */
 	int framenr;	/* number of frame marker is associated with */
+	int flag, pad;	/* Marker's flag (alive, ...) */
 } MovieTrackingMarker;
 
 typedef struct MovieTrackingBundle {
@@ -102,6 +103,9 @@ typedef struct MovieTracking {
 	ListBase bundles;
 } MovieTracking;
 
+/* MovieTrackingMarker->flag */
+#define MARKER_DISABLED	1
+
 /* MovieTrackingTrack->flag */
 #define TRACK_PROCESSED	2