From review: use stereo3d *everywhere* =)

14 files changed, 121 insertions, 121 deletions

diff --git a/source/blender/blenkernel/intern/image.c b/source/blender/blenkernel/intern/image.c
index c2f62220d15..f852d886ae9 100644
--- a/source/blender/blenkernel/intern/image.c
+++ b/source/blender/blenkernel/intern/image.c
@@ -3105,7 +3105,7 @@ static ImBuf *image_load_sequence_file(Image *ima, ImageUser *iuser, int frame)
 			ibuf_arr[i] = load_sequence_single(ima, iuser, frame, i, &assign);
 
 		if ((ima->flag & IMA_IS_STEREO) && ima->views_format == R_IMF_VIEWS_STEREO_3D)
-			IMB_ImBufFromStereo(ima->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
+			IMB_ImBufFromStereo3d(ima->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
 
 		/* return the original requested ImBuf */
 		ibuf = ibuf_arr[(iuser ? iuser->multi_index : 0)];
@@ -3270,7 +3270,7 @@ static ImBuf *image_load_movie_file(Image *ima, ImageUser *iuser, int frame)
 		}
 
 		if ((ima->flag & IMA_IS_STEREO) && ima->views_format == R_IMF_VIEWS_STEREO_3D)
-			IMB_ImBufFromStereo(ima->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
+			IMB_ImBufFromStereo3d(ima->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
 
 		for (i = 0; i < totviews; i++) {
 			if (ibuf_arr[i]) {
@@ -3430,7 +3430,7 @@ static ImBuf *image_load_image_file(Image *ima, ImageUser *iuser, int cfra)
 			ibuf_arr[i] = load_image_single(ima, iuser, cfra, i, has_packed, &assign);
 
 		if ((ima->flag & IMA_IS_STEREO) && ima->views_format == R_IMF_VIEWS_STEREO_3D)
-			IMB_ImBufFromStereo(ima->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
+			IMB_ImBufFromStereo3d(ima->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
 
 		/* return the original requested ImBuf */
 		i = iuser && iuser->multi_index < totviews ? iuser->multi_index : 0;
diff --git a/source/blender/blenkernel/intern/scene.c b/source/blender/blenkernel/intern/scene.c
index cabe1483308..7ff7b129a40 100644
--- a/source/blender/blenkernel/intern/scene.c
+++ b/source/blender/blenkernel/intern/scene.c
@@ -2376,7 +2376,7 @@ void BKE_scene_multiview_videos_dimensions_get(
 	if ((rd->scemode & R_MULTIVIEW) &&
 	    rd->im_format.views_format == R_IMF_VIEWS_STEREO_3D)
 	{
-		IMB_stereo_write_dimensions(
+		IMB_stereo3d_write_dimensions(
 		        rd->im_format.stereo3d_format.display_mode,
 		        (rd->im_format.stereo3d_format.flag & S3D_SQUEEZED_FRAME) != 0,
 		        width, height,
diff --git a/source/blender/blenkernel/intern/sequencer.c b/source/blender/blenkernel/intern/sequencer.c
index d713b594c51..942426febdd 100644
--- a/source/blender/blenkernel/intern/sequencer.c
+++ b/source/blender/blenkernel/intern/sequencer.c
@@ -2755,7 +2755,7 @@ static ImBuf *seq_render_image_strip(const SeqRenderData *context, Sequence *seq
 		}
 
 		if (seq->views_format == R_IMF_VIEWS_STEREO_3D && ibufs_arr[0])
-			IMB_ImBufFromStereo(seq->stereo3d_format, ibufs_arr[0], &ibufs_arr[0], &ibufs_arr[1]);
+			IMB_ImBufFromStereo3d(seq->stereo3d_format, ibufs_arr[0], &ibufs_arr[0], &ibufs_arr[1]);
 
 		for (i = 0; i < totviews; i++) {
 			if (ibufs_arr[i]) {
@@ -2853,7 +2853,7 @@ static ImBuf *seq_render_movie_strip(const SeqRenderData *context, Sequence *seq
 
 		if (seq->views_format == R_IMF_VIEWS_STEREO_3D) {
 			if (ibuf_arr[0]) {
-				IMB_ImBufFromStereo(seq->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
+				IMB_ImBufFromStereo3d(seq->stereo3d_format, ibuf_arr[0], &ibuf_arr[0], &ibuf_arr[1]);
 			}
 			else {
 				/* probably proxy hasn't been created yet */
diff --git a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cpp b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cpp
index 73aa18fdd36..c927dfa89a1 100644
--- a/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cpp
+++ b/source/blender/compositor/operations/COM_OutputFileMultiViewOperation.cpp
@@ -299,7 +299,7 @@ void OutputStereoOperation::deinitExecution()
 			}
 
 			/* create stereo buffer */
-			ibuf[2] = IMB_stereoImBuf(this->m_format, ibuf[0], ibuf[1]);
+			ibuf[2] = IMB_stereo3d_ImBuf(this->m_format, ibuf[0], ibuf[1]);
 
 			BKE_image_path_from_imformat(
 			        filename, this->m_path, bmain->name, this->m_rd->cfra, this->m_format,
diff --git a/source/blender/editors/space_image/image_ops.c b/source/blender/editors/space_image/image_ops.c
index 2afe4e4ac0c..ddbe501e6ef 100644
--- a/source/blender/editors/space_image/image_ops.c
+++ b/source/blender/editors/space_image/image_ops.c
@@ -1843,7 +1843,7 @@ static bool save_image_doit(bContext *C, SpaceImage *sima, wmOperator *op, SaveI
 					BKE_image_release_ibuf(sima->image, ibuf, lock);
 				}
 
-				ibuf = IMB_stereoImBuf(imf, ibuf_stereo[0], ibuf_stereo[1]);
+				ibuf = IMB_stereo3d_ImBuf(imf, ibuf_stereo[0], ibuf_stereo[1]);
 
 				/* save via traditional path */
 				ok = BKE_imbuf_write_as(ibuf, simopts->filepath, imf, save_copy);
diff --git a/source/blender/editors/space_view3d/view3d_draw.c b/source/blender/editors/space_view3d/view3d_draw.c
index 8abd53da584..6e413f71abb 100644
--- a/source/blender/editors/space_view3d/view3d_draw.c
+++ b/source/blender/editors/space_view3d/view3d_draw.c
@@ -3556,7 +3556,7 @@ static bool view3d_stereo3d_active(const bContext *C, Scene *scene, View3D *v3d,
 	if ((scene->r.scemode & R_MULTIVIEW) == 0)
 		return false;
 
-	if (WM_stereo_enabled(win, true) == false)
+	if (WM_stereo3d_enabled(win, true) == false)
 		return false;
 
 	if ((v3d->camera == NULL) || rv3d->persp != RV3D_CAMOB)
diff --git a/source/blender/imbuf/IMB_imbuf.h b/source/blender/imbuf/IMB_imbuf.h
index c93d2e7fdf1..a39832dd1cb 100644
--- a/source/blender/imbuf/IMB_imbuf.h
+++ b/source/blender/imbuf/IMB_imbuf.h
@@ -575,22 +575,22 @@ const char *IMB_ffmpeg_last_error(void);
  *
  * \attention defined in stereoimbuf.c
  */
-void IMB_stereo_write_dimensions(
+void IMB_stereo3d_write_dimensions(
         const char mode, const bool is_squeezed, const size_t width, const size_t height,
         size_t *r_width, size_t *r_height);
-void IMB_stereo_read_dimensions(
+void IMB_stereo3d_read_dimensions(
         const char mode, const bool is_squeezed, const size_t width, const size_t height,
         size_t *r_width, size_t *r_height);
-int *IMB_stereo_from_rect(
+int *IMB_stereo3d_from_rect(
         struct ImageFormatData *im_format, const size_t x, const size_t y, const size_t channels,
         int *rect_left, int *rect_right);
-float *IMB_stereo_from_rectf(
+float *IMB_stereo3d_from_rectf(
         struct ImageFormatData *im_format, const size_t x, const size_t y, const size_t channels,
         float *rectf_left, float *rectf_right);
-struct ImBuf *IMB_stereoImBuf(
+struct ImBuf *IMB_stereo3d_ImBuf(
         struct ImageFormatData *im_format,
         struct ImBuf *ibuf_left, struct ImBuf *ibuf_right);
-void IMB_ImBufFromStereo(
+void IMB_ImBufFromStereo3d(
         struct Stereo3dFormat *s3d, struct ImBuf *ibuf_stereo,
         struct ImBuf **r_ibuf_left, struct ImBuf **r_ibuf_right);
 
diff --git a/source/blender/imbuf/intern/stereoimbuf.c b/source/blender/imbuf/intern/stereoimbuf.c
index a866b8e1e4c..cf9c6b388ff 100644
--- a/source/blender/imbuf/intern/stereoimbuf.c
+++ b/source/blender/imbuf/intern/stereoimbuf.c
@@ -53,8 +53,8 @@
 
 /* prototypes */
 struct Stereo3DData;
-static void imb_stereo_write_doit(struct Stereo3DData *s3d_data, struct Stereo3dFormat *s3d);
-static void imb_stereo_read_doit(struct Stereo3DData *s3d_data, struct Stereo3dFormat *s3d);
+static void imb_stereo3d_write_doit(struct Stereo3DData *s3d_data, struct Stereo3dFormat *s3d);
+static void imb_stereo3d_read_doit(struct Stereo3DData *s3d_data, struct Stereo3dFormat *s3d);
 
 typedef struct Stereo3DData {
 	struct { float *left, *right, *stereo; } rectf;
@@ -63,7 +63,7 @@ typedef struct Stereo3DData {
 	bool is_float;
 } Stereo3DData;
 
-static void imb_stereo_write_anaglyph(Stereo3DData *s3d, enum eStereo3dAnaglyphType mode)
+static void imb_stereo3d_write_anaglyph(Stereo3DData *s3d, enum eStereo3dAnaglyphType mode)
 {
 	int x, y;
 	size_t width = s3d->x;
@@ -161,7 +161,7 @@ static void imb_stereo_write_anaglyph(Stereo3DData *s3d, enum eStereo3dAnaglyphT
 	}
 }
 
-static void imb_stereo_write_interlace(Stereo3DData *s3d, enum eStereo3dInterlaceType mode, const bool swap)
+static void imb_stereo3d_write_interlace(Stereo3DData *s3d, enum eStereo3dInterlaceType mode, const bool swap)
 {
 	int x, y;
 	size_t width = s3d->x;
@@ -424,8 +424,8 @@ static void imb_stereo_write_interlace(Stereo3DData *s3d, enum eStereo3dInterlac
 	}
 }
 
-/* stereo output (s3d->rectf.stereo) is always unsqueezed */
-static void imb_stereo_write_sidebyside(Stereo3DData *s3d, const bool crosseyed)
+/* stereo3d output (s3d->rectf.stereo) is always unsqueezed */
+static void imb_stereo3d_write_sidebyside(Stereo3DData *s3d, const bool crosseyed)
 {
 	int y;
 	size_t width = s3d->x;
@@ -472,8 +472,8 @@ static void imb_stereo_write_sidebyside(Stereo3DData *s3d, const bool crosseyed)
 	}
 }
 
-/* stereo output (s3d->rectf.stereo) is always unsqueezed */
-static void imb_stereo_write_topbottom(Stereo3DData *s3d)
+/* stereo3d output (s3d->rectf.stereo) is always unsqueezed */
+static void imb_stereo3d_write_topbottom(Stereo3DData *s3d)
 {
 	int y;
 	size_t width = s3d->x;
@@ -519,7 +519,7 @@ static void imb_stereo_write_topbottom(Stereo3DData *s3d)
 
 /**************************** dimension utils ****************************************/
 
-void IMB_stereo_write_dimensions(
+void IMB_stereo3d_write_dimensions(
         const char mode, const bool is_squeezed, const size_t width, const size_t height,
         size_t *r_width, size_t *r_height)
 {
@@ -547,7 +547,7 @@ void IMB_stereo_write_dimensions(
 	}
 }
 
-void IMB_stereo_read_dimensions(
+void IMB_stereo3d_read_dimensions(
         const char mode, const bool is_squeezed, const size_t width, const size_t height,
         size_t *r_width, size_t *r_height)
 {
@@ -577,7 +577,7 @@ void IMB_stereo_read_dimensions(
 
 /**************************** un/squeeze frame ****************************************/
 
-static void imb_stereo_squeeze_ImBuf(ImBuf *ibuf, Stereo3dFormat *s3d, const size_t x, const size_t y)
+static void imb_stereo3d_squeeze_ImBuf(ImBuf *ibuf, Stereo3dFormat *s3d, const size_t x, const size_t y)
 {
 	if (ELEM(s3d->display_mode, S3D_DISPLAY_SIDEBYSIDE, S3D_DISPLAY_TOPBOTTOM) == false)
 		return;
@@ -588,7 +588,7 @@ static void imb_stereo_squeeze_ImBuf(ImBuf *ibuf, Stereo3dFormat *s3d, const siz
 	IMB_scaleImBuf_threaded(ibuf, x, y);
 }
 
-static void imb_stereo_unsqueeze_ImBuf(ImBuf *ibuf, Stereo3dFormat *s3d, const size_t x, const size_t y)
+static void imb_stereo3d_unsqueeze_ImBuf(ImBuf *ibuf, Stereo3dFormat *s3d, const size_t x, const size_t y)
 {
 	if (ELEM(s3d->display_mode, S3D_DISPLAY_SIDEBYSIDE, S3D_DISPLAY_TOPBOTTOM) == false)
 		return;
@@ -599,7 +599,7 @@ static void imb_stereo_unsqueeze_ImBuf(ImBuf *ibuf, Stereo3dFormat *s3d, const s
 	IMB_scaleImBuf_threaded(ibuf, x, y);
 }
 
-static void imb_stereo_squeeze_rectf(float *rectf, Stereo3dFormat *s3d, const size_t x, const size_t y, const size_t channels)
+static void imb_stereo3d_squeeze_rectf(float *rectf, Stereo3dFormat *s3d, const size_t x, const size_t y, const size_t channels)
 {
 	ImBuf *ibuf;
 	size_t width, height;
@@ -611,7 +611,7 @@ static void imb_stereo_squeeze_rectf(float *rectf, Stereo3dFormat *s3d, const si
 		return;
 
 	/* creates temporary imbuf to store the rectf */
-	IMB_stereo_write_dimensions(s3d->display_mode, false, x, y, &width, &height);
+	IMB_stereo3d_write_dimensions(s3d->display_mode, false, x, y, &width, &height);
 	ibuf = IMB_allocImBuf(width, height, channels, IB_rectfloat);
 
 	IMB_buffer_float_from_float(
@@ -624,7 +624,7 @@ static void imb_stereo_squeeze_rectf(float *rectf, Stereo3dFormat *s3d, const si
 	IMB_freeImBuf(ibuf);
 }
 
-static void imb_stereo_squeeze_rect(int *rect, Stereo3dFormat *s3d, const size_t x, const size_t y, const size_t channels)
+static void imb_stereo3d_squeeze_rect(int *rect, Stereo3dFormat *s3d, const size_t x, const size_t y, const size_t channels)
 {
 	ImBuf *ibuf;
 	size_t width, height;
@@ -636,7 +636,7 @@ static void imb_stereo_squeeze_rect(int *rect, Stereo3dFormat *s3d, const size_t
 		return;
 
 	/* creates temporary imbuf to store the rectf */
-	IMB_stereo_write_dimensions(s3d->display_mode, false, x, y, &width, &height);
+	IMB_stereo3d_write_dimensions(s3d->display_mode, false, x, y, &width, &height);
 	ibuf = IMB_allocImBuf(width, height, channels, IB_rect);
 
 	IMB_buffer_byte_from_byte(
@@ -652,7 +652,7 @@ static void imb_stereo_squeeze_rect(int *rect, Stereo3dFormat *s3d, const size_t
 
 /*************************** preparing to call the write functions **************************/
 
-static void imb_stereo_data_initialize(
+static void imb_stereo3d_data_initialize(
         Stereo3DData *s3d_data, const bool is_float,
         const size_t x, const size_t y, const size_t channels,
         int *rect_left, int *rect_right, int *rect_stereo,
@@ -670,7 +670,7 @@ static void imb_stereo_data_initialize(
 	s3d_data->rectf.stereo = rectf_stereo;
 }
 
-int *IMB_stereo_from_rect(
+int *IMB_stereo3d_from_rect(
         ImageFormatData *im_format, const size_t x, const size_t y, const size_t channels,
         int *rect_left, int *rect_right)
 {
@@ -679,17 +679,17 @@ int *IMB_stereo_from_rect(
 	size_t width, height;
 	const bool is_float = im_format->depth > 8;
 
-	IMB_stereo_write_dimensions(im_format->stereo3d_format.display_mode, false, x, y, &width, &height);
+	IMB_stereo3d_write_dimensions(im_format->stereo3d_format.display_mode, false, x, y, &width, &height);
 	r_rect = MEM_mallocN(channels * sizeof(int) * width * height, __func__);
 
-	imb_stereo_data_initialize(&s3d_data, is_float, x, y, channels, rect_left, rect_right, r_rect, NULL, NULL, NULL);
-	imb_stereo_write_doit(&s3d_data, &im_format->stereo3d_format);
-	imb_stereo_squeeze_rect(r_rect, &im_format->stereo3d_format, x, y, channels);
+	imb_stereo3d_data_initialize(&s3d_data, is_float, x, y, channels, rect_left, rect_right, r_rect, NULL, NULL, NULL);
+	imb_stereo3d_write_doit(&s3d_data, &im_format->stereo3d_format);
+	imb_stereo3d_squeeze_rect(r_rect, &im_format->stereo3d_format, x, y, channels);
 
 	return r_rect;
 }
 
-float *IMB_stereo_from_rectf(
+float *IMB_stereo3d_from_rectf(
         ImageFormatData *im_format, const size_t x, const size_t y, const size_t channels,
         float *rectf_left, float *rectf_right)
 {
@@ -698,55 +698,55 @@ float *IMB_stereo_from_rectf(
 	size_t width, height;
 	const bool is_float = im_format->depth > 8;
 
-	IMB_stereo_write_dimensions(im_format->stereo3d_format.display_mode, false, x, y, &width, &height);
+	IMB_stereo3d_write_dimensions(im_format->stereo3d_format.display_mode, false, x, y, &width, &height);
 	r_rectf = MEM_mallocN(channels * sizeof(float) * width * height, __func__);
 
-	imb_stereo_data_initialize(&s3d_data, is_float, x, y, channels, NULL, NULL, NULL, rectf_left, rectf_right, r_rectf);
-	imb_stereo_write_doit(&s3d_data, &im_format->stereo3d_format);
-	imb_stereo_squeeze_rectf(r_rectf, &im_format->stereo3d_format, x, y, channels);
+	imb_stereo3d_data_initialize(&s3d_data, is_float, x, y, channels, NULL, NULL, NULL, rectf_left, rectf_right, r_rectf);
+	imb_stereo3d_write_doit(&s3d_data, &im_format->stereo3d_format);
+	imb_stereo3d_squeeze_rectf(r_rectf, &im_format->stereo3d_format, x, y, channels);
 
 	return r_rectf;
 }
 
 /* left/right are always float */
-ImBuf *IMB_stereoImBuf(ImageFormatData *im_format, ImBuf *ibuf_left, ImBuf *ibuf_right)
+ImBuf *IMB_stereo3d_ImBuf(ImageFormatData *im_format, ImBuf *ibuf_left, ImBuf *ibuf_right)
 {
 	ImBuf *ibuf_stereo = NULL;
 	Stereo3DData s3d_data = {{NULL}};
 	size_t width, height;
 	const bool is_float = im_format->depth > 8;
 
-	IMB_stereo_write_dimensions(im_format->stereo3d_format.display_mode, false, ibuf_left->x, ibuf_left->y, &width, &height);
+	IMB_stereo3d_write_dimensions(im_format->stereo3d_format.display_mode, false, ibuf_left->x, ibuf_left->y, &width, &height);
 	ibuf_stereo = IMB_allocImBuf(width, height, ibuf_left->planes, (is_float ? IB_rectfloat : IB_rect));
 
 	/* copy flags for IB_fields and other settings */
 	ibuf_stereo->flags = ibuf_left->flags;
 
-	imb_stereo_data_initialize(
+	imb_stereo3d_data_initialize(
 	        &s3d_data, is_float, ibuf_left->x, ibuf_left->y, 4,
 	        (int *)ibuf_left->rect, (int *)ibuf_right->rect, (int *)ibuf_stereo->rect,
 	        ibuf_left->rect_float, ibuf_right->rect_float, ibuf_stereo->rect_float);
 
-	imb_stereo_write_doit(&s3d_data, &im_format->stereo3d_format);
-	imb_stereo_squeeze_ImBuf(ibuf_stereo, &im_format->stereo3d_format, ibuf_left->x, ibuf_left->y);
+	imb_stereo3d_write_doit(&s3d_data, &im_format->stereo3d_format);
+	imb_stereo3d_squeeze_ImBuf(ibuf_stereo, &im_format->stereo3d_format, ibuf_left->x, ibuf_left->y);
 
 	return ibuf_stereo;
 }
 
-static void imb_stereo_write_doit(Stereo3DData *s3d_data, Stereo3dFormat *s3d)
+static void imb_stereo3d_write_doit(Stereo3DData *s3d_data, Stereo3dFormat *s3d)
 {
 	switch (s3d->display_mode) {
 		case S3D_DISPLAY_ANAGLYPH:
-			imb_stereo_write_anaglyph(s3d_data, s3d->anaglyph_type);
+			imb_stereo3d_write_anaglyph(s3d_data, s3d->anaglyph_type);
 			break;
 		case S3D_DISPLAY_INTERLACE:
-			imb_stereo_write_interlace(s3d_data, s3d->interlace_type, (s3d->flag & S3D_INTERLACE_SWAP) != 0);
+			imb_stereo3d_write_interlace(s3d_data, s3d->interlace_type, (s3d->flag & S3D_INTERLACE_SWAP) != 0);
 			break;
 		case S3D_DISPLAY_SIDEBYSIDE:
-			imb_stereo_write_sidebyside(s3d_data, (s3d->flag & S3D_SIDEBYSIDE_CROSSEYED) != 0);
+			imb_stereo3d_write_sidebyside(s3d_data, (s3d->flag & S3D_SIDEBYSIDE_CROSSEYED) != 0);
 			break;
 		case S3D_DISPLAY_TOPBOTTOM:
-			imb_stereo_write_topbottom(s3d_data);
+			imb_stereo3d_write_topbottom(s3d_data);
 			break;
 		default:
 			break;
@@ -755,7 +755,7 @@ static void imb_stereo_write_doit(Stereo3DData *s3d_data, Stereo3dFormat *s3d)
 
 /******************************** reading stereo imbufs **********************/
 
-static void imb_stereo_read_anaglyph(Stereo3DData *s3d, enum eStereo3dAnaglyphType mode)
+static void imb_stereo3d_read_anaglyph(Stereo3DData *s3d, enum eStereo3dAnaglyphType mode)
 {
 	int x, y;
 	size_t width = s3d->x;
@@ -853,7 +853,7 @@ static void imb_stereo_read_anaglyph(Stereo3DData *s3d, enum eStereo3dAnaglyphTy
 	}
 }
 
-static void imb_stereo_read_interlace(Stereo3DData *s3d, enum eStereo3dInterlaceType mode, const bool swap)
+static void imb_stereo3d_read_interlace(Stereo3DData *s3d, enum eStereo3dInterlaceType mode, const bool swap)
 {
 	int x, y;
 	size_t width = s3d->x;
@@ -1117,7 +1117,7 @@ static void imb_stereo_read_interlace(Stereo3DData *s3d, enum eStereo3dInterlace
 }
 
 /* stereo input (s3d->rectf.stereo) is always unsqueezed */
-static void imb_stereo_read_sidebyside(Stereo3DData *s3d, const bool crosseyed)
+static void imb_stereo3d_read_sidebyside(Stereo3DData *s3d, const bool crosseyed)
 {
 	int y;
 	size_t width = s3d->x;
@@ -1166,7 +1166,7 @@ static void imb_stereo_read_sidebyside(Stereo3DData *s3d, const bool crosseyed)
 }
 
 /* stereo input (s3d->rectf.stereo) is always unsqueezed */
-static void imb_stereo_read_topbottom(Stereo3DData *s3d)
+static void imb_stereo3d_read_topbottom(Stereo3DData *s3d)
 {
 	int y;
 	size_t width = s3d->x;
@@ -1214,40 +1214,40 @@ static void imb_stereo_read_topbottom(Stereo3DData *s3d)
 /*************************** preparing to call the read functions **************************/
 
 /* reading a stereo encoded ibuf (*left) and generating two ibufs from it (*left and *right) */
-void IMB_ImBufFromStereo(
-        Stereo3dFormat *s3d, ImBuf *ibuf_stereo,
+void IMB_ImBufFromStereo3d(
+        Stereo3dFormat *s3d, ImBuf *ibuf_stereo3d,
         ImBuf **r_ibuf_left, ImBuf **r_ibuf_right)
 {
 	Stereo3DData s3d_data = {{NULL}};
 	ImBuf *ibuf_left, *ibuf_right;
 	size_t width, height;
-	const bool is_float = (ibuf_stereo->rect_float != NULL);
+	const bool is_float = (ibuf_stereo3d->rect_float != NULL);
 
-	IMB_stereo_read_dimensions(
-	        s3d->display_mode, ((s3d->flag & S3D_SQUEEZED_FRAME) == 0), ibuf_stereo->x, ibuf_stereo->y,
+	IMB_stereo3d_read_dimensions(
+	        s3d->display_mode, ((s3d->flag & S3D_SQUEEZED_FRAME) == 0), ibuf_stereo3d->x, ibuf_stereo3d->y,
 	        &width, &height);
 
-	ibuf_left = IMB_allocImBuf(width, height, ibuf_stereo->planes, (is_float ? IB_rectfloat : IB_rect));
-	ibuf_right = IMB_allocImBuf(width, height, ibuf_stereo->planes, (is_float ? IB_rectfloat : IB_rect));
+	ibuf_left = IMB_allocImBuf(width, height, ibuf_stereo3d->planes, (is_float ? IB_rectfloat : IB_rect));
+	ibuf_right = IMB_allocImBuf(width, height, ibuf_stereo3d->planes, (is_float ? IB_rectfloat : IB_rect));
 
 	/* copy flags for IB_fields and other settings */
-	ibuf_left->flags = ibuf_stereo->flags;
-	ibuf_right->flags = ibuf_stereo->flags;
+	ibuf_left->flags = ibuf_stereo3d->flags;
+	ibuf_right->flags = ibuf_stereo3d->flags;
 
 	/* we always work with unsqueezed formats */
-	IMB_stereo_write_dimensions(
-	        s3d->display_mode, ((s3d->flag & S3D_SQUEEZED_FRAME) == 0), ibuf_stereo->x, ibuf_stereo->y,
+	IMB_stereo3d_write_dimensions(
+	        s3d->display_mode, ((s3d->flag & S3D_SQUEEZED_FRAME) == 0), ibuf_stereo3d->x, ibuf_stereo3d->y,
 	        &width, &height);
-	imb_stereo_unsqueeze_ImBuf(ibuf_stereo, s3d, width, height);
+	imb_stereo3d_unsqueeze_ImBuf(ibuf_stereo3d, s3d, width, height);
 
-	imb_stereo_data_initialize(
+	imb_stereo3d_data_initialize(
 	        &s3d_data, is_float, ibuf_left->x, ibuf_left->y, 4,
-	        (int *)ibuf_left->rect, (int *)ibuf_right->rect, (int *)ibuf_stereo->rect,
-	        ibuf_left->rect_float, ibuf_right->rect_float, ibuf_stereo->rect_float);
+	        (int *)ibuf_left->rect, (int *)ibuf_right->rect, (int *)ibuf_stereo3d->rect,
+	        ibuf_left->rect_float, ibuf_right->rect_float, ibuf_stereo3d->rect_float);
 
-	imb_stereo_read_doit(&s3d_data, s3d);
+	imb_stereo3d_read_doit(&s3d_data, s3d);
 
-	if (ibuf_stereo->flags & (IB_zbuf | IB_zbuffloat)) {
+	if (ibuf_stereo3d->flags & (IB_zbuf | IB_zbuffloat)) {
 		if (is_float) {
 			addzbuffloatImBuf(ibuf_left);
 			addzbuffloatImBuf(ibuf_right);
@@ -1257,34 +1257,34 @@ void IMB_ImBufFromStereo(
 			addzbufImBuf(ibuf_right);
 		}
 
-		imb_stereo_data_initialize(
+		imb_stereo3d_data_initialize(
 		        &s3d_data, is_float, ibuf_left->x, ibuf_left->y, 1,
-		        (int *)ibuf_left->zbuf, (int *)ibuf_right->zbuf, (int *)ibuf_stereo->zbuf,
-		        ibuf_left->zbuf_float, ibuf_right->zbuf_float, ibuf_stereo->zbuf_float);
+		        (int *)ibuf_left->zbuf, (int *)ibuf_right->zbuf, (int *)ibuf_stereo3d->zbuf,
+		        ibuf_left->zbuf_float, ibuf_right->zbuf_float, ibuf_stereo3d->zbuf_float);
 
-		imb_stereo_read_doit(&s3d_data, s3d);
+		imb_stereo3d_read_doit(&s3d_data, s3d);
 	}
 
-	IMB_freeImBuf(ibuf_stereo);
+	IMB_freeImBuf(ibuf_stereo3d);
 
 	*r_ibuf_left = ibuf_left;
 	*r_ibuf_right = ibuf_right;
 }
 
-static void imb_stereo_read_doit(Stereo3DData *s3d_data, Stereo3dFormat *s3d)
+static void imb_stereo3d_read_doit(Stereo3DData *s3d_data, Stereo3dFormat *s3d)
 {
 	switch (s3d->display_mode) {
 		case S3D_DISPLAY_ANAGLYPH:
-			imb_stereo_read_anaglyph(s3d_data, s3d->anaglyph_type);
+			imb_stereo3d_read_anaglyph(s3d_data, s3d->anaglyph_type);
 			break;
 		case S3D_DISPLAY_INTERLACE:
-			imb_stereo_read_interlace(s3d_data, s3d->interlace_type, (s3d->flag & S3D_INTERLACE_SWAP) != 0);
+			imb_stereo3d_read_interlace(s3d_data, s3d->interlace_type, (s3d->flag & S3D_INTERLACE_SWAP) != 0);
 			break;
 		case S3D_DISPLAY_SIDEBYSIDE:
-			imb_stereo_read_sidebyside(s3d_data, (s3d->flag & S3D_SIDEBYSIDE_CROSSEYED) != 0);
+			imb_stereo3d_read_sidebyside(s3d_data, (s3d->flag & S3D_SIDEBYSIDE_CROSSEYED) != 0);
 			break;
 		case S3D_DISPLAY_TOPBOTTOM:
-			imb_stereo_read_topbottom(s3d_data);
+			imb_stereo3d_read_topbottom(s3d_data);
 			break;
 		default:
 			break;
diff --git a/source/blender/render/intern/source/pipeline.c b/source/blender/render/intern/source/pipeline.c
index e7bbb648990..42d14288569 100644
--- a/source/blender/render/intern/source/pipeline.c
+++ b/source/blender/render/intern/source/pipeline.c
@@ -3186,7 +3186,7 @@ bool RE_WriteRenderViewsImage(ReportList *reports, RenderResult *rr, Scene *scen
 				IMB_prepare_write_ImBuf(IMB_isfloat(ibuf_arr[i]), ibuf_arr[i]);
 			}
 
-			ibuf_arr[2] = IMB_stereoImBuf(&scene->r.im_format, ibuf_arr[0], ibuf_arr[1]);
+			ibuf_arr[2] = IMB_stereo3d_ImBuf(&scene->r.im_format, ibuf_arr[0], ibuf_arr[1]);
 
 			if (stamp)
 				ok = BKE_imbuf_write_stamp(scene, camera, ibuf_arr[2], name, &rd->im_format);
@@ -3299,7 +3299,7 @@ bool RE_WriteRenderViewsMovie(ReportList *reports, RenderResult *rr, Scene *scen
 			                                    &scene->display_settings, &scene->r.im_format);
 		}
 
-		ibuf_arr[2] = IMB_stereoImBuf(&scene->r.im_format, ibuf_arr[0], ibuf_arr[1]);
+		ibuf_arr[2] = IMB_stereo3d_ImBuf(&scene->r.im_format, ibuf_arr[0], ibuf_arr[1]);
 
 		ok = mh->append_movie(movie_ctx_arr[0], rd, scene->r.sfra, scene->r.cfra, (int *) ibuf_arr[2]->rect,
 		                      ibuf_arr[2]->x, ibuf_arr[2]->y, "", reports);
diff --git a/source/blender/windowmanager/WM_api.h b/source/blender/windowmanager/WM_api.h
index a815abea510..dbeea80ba82 100644
--- a/source/blender/windowmanager/WM_api.h
+++ b/source/blender/windowmanager/WM_api.h
@@ -103,7 +103,7 @@ void		WM_window_open_temp	(struct bContext *C, struct rcti *position, int type);
 			/* returns true if draw method is triple buffer */
 bool		WM_is_draw_triple(struct wmWindow *win);
 
-bool		WM_stereo_enabled(struct wmWindow *win, bool only_fullscreen_test);
+bool		WM_stereo3d_enabled(struct wmWindow *win, bool only_fullscreen_test);
 
 
 			/* files */
diff --git a/source/blender/windowmanager/intern/wm_draw.c b/source/blender/windowmanager/intern/wm_draw.c
index 135277221de..16fe9ca5142 100644
--- a/source/blender/windowmanager/intern/wm_draw.c
+++ b/source/blender/windowmanager/intern/wm_draw.c
@@ -1043,13 +1043,13 @@ void wm_draw_update(bContext *C)
 			else if (drawmethod == USER_DRAW_OVERLAP_FLIP)
 				wm_method_draw_overlap_all(C, win, 1);
 			else { /* USER_DRAW_TRIPLE */
-				if ((WM_stereo_enabled(win, false)) == false) {
+				if ((WM_stereo3d_enabled(win, false)) == false) {
 					wm_method_draw_triple(C, win);
 				}
 				else {
 					wm_method_draw_triple_multiview(C, win, STEREO_LEFT_ID);
 					wm_method_draw_triple_multiview(C, win, STEREO_RIGHT_ID);
-					wm_method_draw_stereo(C, win);
+					wm_method_draw_stereo3d(C, win);
 				}
 			}
 
diff --git a/source/blender/windowmanager/intern/wm_operators.c b/source/blender/windowmanager/intern/wm_operators.c
index 398017c2aa6..9e4738122fe 100644
--- a/source/blender/windowmanager/intern/wm_operators.c
+++ b/source/blender/windowmanager/intern/wm_operators.c
@@ -4846,11 +4846,11 @@ static void WM_OT_stereo3d_set(wmOperatorType *ot)
 	ot->idname = "WM_OT_set_stereo_3d";
 	ot->description = "Toggle 3D stereo support for current window (or change the display mode)";
 
-	ot->exec = wm_set_stereo3d_exec;
-	ot->invoke = wm_set_stereo3d_invoke;
+	ot->exec = wm_stereo3d_set_exec;
+	ot->invoke = wm_stereo3d_set_invoke;
 	ot->poll = WM_operator_winactive;
-	ot->ui = wm_set_stereo3d_draw;
-	ot->cancel = wm_set_stereo3d_cancel;
+	ot->ui = wm_stereo3d_set_draw;
+	ot->cancel = wm_stereo3d_set_cancel;
 
 	prop = RNA_def_enum(ot->srna, "display_mode", stereo3d_display_items, S3D_DISPLAY_ANAGLYPH, "Display Mode", "");
 	RNA_def_property_flag(prop, PROP_SKIP_SAVE);
diff --git a/source/blender/windowmanager/intern/wm_stereo.c b/source/blender/windowmanager/intern/wm_stereo.c
index 7dd951986a6..5d7b11272c6 100644
--- a/source/blender/windowmanager/intern/wm_stereo.c
+++ b/source/blender/windowmanager/intern/wm_stereo.c
@@ -64,7 +64,7 @@
 #include "UI_interface.h"
 #include "UI_resources.h"
 
-static void wm_method_draw_stereo_pageflip(wmWindow *win)
+static void wm_method_draw_stereo3d_pageflip(wmWindow *win)
 {
 	wmDrawData *drawdata;
 	int view;
@@ -135,7 +135,7 @@ static void wm_interlace_masks_create(wmWindow *win)
 	interlace_prev_swap = swap;
 }
 
-static void wm_method_draw_stereo_interlace(wmWindow *win)
+static void wm_method_draw_stereo3d_interlace(wmWindow *win)
 {
 	wmDrawData *drawdata;
 	int view;
@@ -153,7 +153,7 @@ static void wm_method_draw_stereo_interlace(wmWindow *win)
 	}
 }
 
-static void wm_method_draw_stereo_anaglyph(wmWindow *win)
+static void wm_method_draw_stereo3d_anaglyph(wmWindow *win)
 {
 	wmDrawData *drawdata;
 	int view, bit;
@@ -189,7 +189,7 @@ static void wm_method_draw_stereo_anaglyph(wmWindow *win)
 	}
 }
 
-static void wm_method_draw_stereo_sidebyside(wmWindow *win)
+static void wm_method_draw_stereo3d_sidebyside(wmWindow *win)
 {
 	wmDrawData *drawdata;
 	wmDrawTriple *triple;
@@ -260,7 +260,7 @@ static void wm_method_draw_stereo_sidebyside(wmWindow *win)
 	}
 }
 
-static void wm_method_draw_stereo_topbottom(wmWindow *win)
+static void wm_method_draw_stereo3d_topbottom(wmWindow *win)
 {
 	wmDrawData *drawdata;
 	wmDrawTriple *triple;
@@ -277,7 +277,7 @@ static void wm_method_draw_stereo_topbottom(wmWindow *win)
 		if (view == STEREO_LEFT_ID) {
 			soffy = WM_window_pixels_y(win) * 0.5f;
 		}
-		else { //STEREO_RIGHT_ID
+		else { /* STEREO_RIGHT_ID */
 			soffy = 0;
 		}
 
@@ -327,30 +327,30 @@ static void wm_method_draw_stereo_topbottom(wmWindow *win)
 	}
 }
 
-void wm_method_draw_stereo(const bContext *UNUSED(C), wmWindow *win)
+void wm_method_draw_stereo3d(const bContext *UNUSED(C), wmWindow *win)
 {
 	switch (win->stereo3d_format->display_mode) {
 		case S3D_DISPLAY_ANAGLYPH:
-			wm_method_draw_stereo_anaglyph(win);
+			wm_method_draw_stereo3d_anaglyph(win);
 			break;
 		case S3D_DISPLAY_INTERLACE:
-			wm_method_draw_stereo_interlace(win);
+			wm_method_draw_stereo3d_interlace(win);
 			break;
 		case S3D_DISPLAY_PAGEFLIP:
-			wm_method_draw_stereo_pageflip(win);
+			wm_method_draw_stereo3d_pageflip(win);
 			break;
 		case S3D_DISPLAY_SIDEBYSIDE:
-			wm_method_draw_stereo_sidebyside(win);
+			wm_method_draw_stereo3d_sidebyside(win);
 			break;
 		case S3D_DISPLAY_TOPBOTTOM:
-			wm_method_draw_stereo_topbottom(win);
+			wm_method_draw_stereo3d_topbottom(win);
 			break;
 		default:
 			break;
 	}
 }
 
-static bool wm_stereo_is_fullscreen_required(eStereoDisplayMode stereo_display)
+static bool wm_stereo3d_is_fullscreen_required(eStereoDisplayMode stereo_display)
 {
 	return ELEM(stereo_display,
 	            S3D_DISPLAY_SIDEBYSIDE,
@@ -358,14 +358,14 @@ static bool wm_stereo_is_fullscreen_required(eStereoDisplayMode stereo_display)
 	            S3D_DISPLAY_PAGEFLIP);
 }
 
-bool WM_stereo_enabled(wmWindow *win, bool skip_stereo_check)
+bool WM_stereo3d_enabled(wmWindow *win, bool skip_stereo3d_check)
 {
 	bScreen *screen = win->screen;
 
-	if ((skip_stereo_check == false) && (ED_screen_stereo3d_required(screen) == false))
+	if ((skip_stereo3d_check == false) && (ED_screen_stereo3d_required(screen) == false))
 		return false;
 
-	if (wm_stereo_is_fullscreen_required(win->stereo3d_format->display_mode))
+	if (wm_stereo3d_is_fullscreen_required(win->stereo3d_format->display_mode))
 		return WM_window_is_fullscreen(win);
 
 	return true;
@@ -422,7 +422,7 @@ static bool wm_stereo3d_set_properties(bContext *C, wmOperator *op)
 	return is_set;
 }
 
-static void wm_set_stereo3d_init(bContext *C, wmOperator *op)
+static void wm_stereo3d_set_init(bContext *C, wmOperator *op)
 {
 	Stereo3dData *s3dd;
 	wmWindow *win = CTX_wm_window(C);
@@ -433,7 +433,7 @@ static void wm_set_stereo3d_init(bContext *C, wmOperator *op)
 	s3dd->stereo3d_format = *win->stereo3d_format;
 }
 
-int wm_set_stereo3d_exec(bContext *C, wmOperator *op)
+int wm_stereo3d_set_exec(bContext *C, wmOperator *op)
 {
 	wmWindowManager *wm = CTX_wm_manager(C);
 	wmWindow *win = CTX_wm_window(C);
@@ -455,7 +455,7 @@ int wm_set_stereo3d_exec(bContext *C, wmOperator *op)
 		}
 	}
 
-	if (wm_stereo_is_fullscreen_required(win->stereo3d_format->display_mode)) {
+	if (wm_stereo3d_is_fullscreen_required(win->stereo3d_format->display_mode)) {
 		if (!is_fullscreen) {
 			wm_window_fullscreen_toggle_exec(C, op);
 		}
@@ -469,17 +469,17 @@ int wm_set_stereo3d_exec(bContext *C, wmOperator *op)
 	return OPERATOR_FINISHED;
 }
 
-int wm_set_stereo3d_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
+int wm_stereo3d_set_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
 {
-	wm_set_stereo3d_init(C, op);
+	wm_stereo3d_set_init(C, op);
 
 	if (wm_stereo3d_set_properties(C, op))
-		return wm_set_stereo3d_exec(C, op);
+		return wm_stereo3d_set_exec(C, op);
 	else
 		return WM_operator_props_dialog_popup(C, op, 250, 100);
 }
 
-void wm_set_stereo3d_draw(bContext *C, wmOperator *op)
+void wm_stereo3d_set_draw(bContext *C, wmOperator *op)
 {
 	wmWindow *win = CTX_wm_window(C);
 	Stereo3dFormat *stereo3d_format;
@@ -519,7 +519,7 @@ void wm_set_stereo3d_draw(bContext *C, wmOperator *op)
 	}
 }
 
-void wm_set_stereo3d_cancel(bContext *C, wmOperator *op)
+void wm_stereo3d_set_cancel(bContext *C, wmOperator *op)
 {
 	Stereo3dData *s3dd = op->customdata;
 	wmWindow *win = CTX_wm_window(C);
diff --git a/source/blender/windowmanager/wm.h b/source/blender/windowmanager/wm.h
index 305965498a1..bc777b74b51 100644
--- a/source/blender/windowmanager/wm.h
+++ b/source/blender/windowmanager/wm.h
@@ -77,11 +77,11 @@ void wm_autosave_read(bContext *C, struct ReportList *reports);
 void wm_autosave_location(char *filepath);
 
 /* wm_stereo.c */
-void wm_method_draw_stereo(const bContext *C, wmWindow *win);
-int wm_set_stereo3d_exec(bContext *C, wmOperator *op);
-int wm_set_stereo3d_invoke(bContext *C, wmOperator *op, const wmEvent *event);
-void wm_set_stereo3d_draw(bContext *C, wmOperator *op);
-void wm_set_stereo3d_cancel(bContext *C, wmOperator *op);
+void wm_method_draw_stereo3d(const bContext *C, wmWindow *win);
+int wm_stereo3d_set_exec(bContext *C, wmOperator *op);
+int wm_stereo3d_set_invoke(bContext *C, wmOperator *op, const wmEvent *event);
+void wm_stereo3d_set_draw(bContext *C, wmOperator *op);
+void wm_stereo3d_set_cancel(bContext *C, wmOperator *op);
 
 /* init operator properties */
 void wm_open_init_load_ui(wmOperator *op, bool use_prefs);