Remove public API for video_buffer_forbitmask()

No, it won't come back, but you can get (almost) the same functionality via `video_domain_formem()` (with the only exception being that the later doesn't support non-byte-aligned strides)

Author: GrieferAtWork

kos/include/libvideo/gfx/buffer.h

@@ -679,36 +679,6 @@ __CXXDECL_END
 __DEFINE_REFCNT_FUNCTIONS(struct video_buffer, vb_refcnt, video_buffer_destroy)
 
 
-#if 1 /* TODO: BEGIN DEPRECATED */
-
-/* Create a video buffer that represents the pixel data defined by  a
- * given `__bm' (bitmask). This function is primarily used internally
- * by `video_gfx_absfillmask()' and  `video_gfx_absfillstretchmask()'
- * to deal with  GFX contexts  where the bitmask  cannot be  rendered
- * using  the default method,  but has to be  rendered by being blit.
- *
- * @param: __size_x:       Width of the given `__bm' (in pixels)
- * @param: __size_y:       Height of the given `__bm' (in pixels)
- * @param: __bm:           Bitmask whose data should be referenced interpreted
- * @param: __bg_fg_colors: Colors that 0/1 bits of `__bm' should map to
- * @return: * :   The newly created video buffer
- * @return: NULL: [errno=ENOMEM] Insufficient memory (won't happen when
- *                               used internally, where struct is  just
- *                               allocated on-stack) */
-typedef __ATTR_WUNUSED_T __ATTR_IN_T(3) __ATTR_IN_T(4) __REF struct video_buffer *
-(LIBVIDEO_GFX_CC *PVIDEO_BUFFER_FORBITMASK)(video_dim_t __size_x, video_dim_t __size_y,
-                                            struct video_bitmask const *__restrict __bm,
-                                            video_color_t const __bg_fg_colors[2]);
-#ifdef LIBVIDEO_GFX_WANT_PROTOTYPES
-LIBVIDEO_GFX_DECL __ATTR_WUNUSED __ATTR_IN(3) __ATTR_IN(4) __REF struct video_buffer *LIBVIDEO_GFX_CC
-video_buffer_forbitmask(video_dim_t __size_x, video_dim_t __size_y,
-                        struct video_bitmask const *__restrict __bm,
-                        video_color_t const __bg_fg_colors[2]);
-#endif /* LIBVIDEO_GFX_WANT_PROTOTYPES */
-
-#endif /* TODO: END DEPRECATED */
-
-
 /* Convert `__self' into the specified domain and format. */
 typedef __ATTR_WUNUSED_T __ATTR_INOUT_T(1) __ATTR_NONNULL_T((2)) __ATTR_IN_T(3) __REF struct video_buffer *
 (LIBVIDEO_GFX_CC *PVIDEO_BUFFER_CONVERT)(struct video_buffer *__restrict __self,
@@ -768,6 +738,11 @@ typedef void __NOTHROW_T(LIBVIDEO_GFX_CC *video_buffer_custom_revoke_t)(void *__
 typedef __ATTR_WUNUSED_T __ATTR_NONNULL_T((3, 4, 5)) __REF struct video_buffer *
 (LIBVIDEO_GFX_CC *PVIDEO_BUFFER_FORCUSTOM)(video_dim_t __size_x, video_dim_t __size_y,
                                            struct video_format const *__restrict __format,
+                                           /* TODO: Instead of passing each operator individually,
+                                            *       define  a helper struct that packages them all
+                                            *       together, and document  that said struct  gets
+                                            *       copied (and doesn't need to remain valid) once
+                                            *       this call returns. */
                                            video_buffer_custom_getpixel_t __getpixel,
                                            video_buffer_custom_setpixel_t __setpixel,
                                            video_buffer_custom_destroy_t __destroy,

kos/src/libvideo/gfx/buffer/bitmask.c kos/src/libvideo/gfx/buffer/old-bitmask.ckos/src/libvideo/gfx/buffer/bitmask.c renamed to kos/src/libvideo/gfx/buffer/old-bitmask.c

@@ -48,7 +48,7 @@
 #include "../gfx.h"
 #include "../ramdomain.h"
 #include "../swgfx.h"
-#include "bitmask.h"
+#include "old-bitmask.h"
 
 DECL_BEGIN
 
@@ -70,10 +70,10 @@ bitmask_destroy(struct video_buffer *__restrict self) {
 PRIVATE ATTR_INOUT(1) ATTR_OUT(2) int FCC
 bitmask_lock(struct video_buffer *__restrict self,
              struct video_lock *__restrict lock) {
-	struct bitmask_buffer *me = (struct bitmask_buffer *)self;
+	struct old_bitmask_buffer *me = (struct old_bitmask_buffer *)self;
 	if ((me->bmb_bm.vbm_scan & 7) || me->bmb_bm.vbm_skip) {
 		/* Not scanline-aligned -> cannot "lock" into memory */
-		errno = EINVAL;
+		errno = ENOTSUP;
 		return -1;
 	}
 	lock->vl_data   = (byte_t *)me->bmb_bm.vbm_mask;
@@ -86,11 +86,11 @@ bitmask_lock(struct video_buffer *__restrict self,
 PRIVATE ATTR_INOUT(1) NONNULL((2)) int FCC
 bitmask_lockregion(struct video_buffer *__restrict self,
                    struct video_regionlock *__restrict lock) {
-	struct bitmask_buffer *me = (struct bitmask_buffer *)self;
+	struct old_bitmask_buffer *me = (struct old_bitmask_buffer *)self;
 	video_regionlock_assert(me, lock);
 	if (me->bmb_bm.vbm_scan & 7) {
 		/* Not scanline-aligned -> cannot "lock" into memory */
-		errno = EINVAL;
+		errno = ENOTSUP;
 		return -1;
 	}
 	lock->vrl_lock.vl_stride = me->bmb_bm.vbm_scan >> 3;
@@ -103,7 +103,7 @@ bitmask_lockregion(struct video_buffer *__restrict self,
 PRIVATE ATTR_IN(1) video_pixel_t CC
 bitmask_gfx__getpixel(struct video_gfx const *__restrict self,
                       video_coord_t x, video_coord_t y) {
-	struct bitmask_buffer *me = (struct bitmask_buffer *)self->vx_buffer;
+	struct old_bitmask_buffer *me = (struct old_bitmask_buffer *)self->vx_buffer;
 	uintptr_t bitoff = me->bmb_bm.vbm_skip + x + y * me->bmb_bm.vbm_scan;
 	byte_t const *bm = (byte_t const *)me->bmb_bm.vbm_mask;
 	return (bm[bitoff >> 3] >> (7 - (bitoff & 7))) & 1;
@@ -113,7 +113,7 @@ PRIVATE ATTR_IN(1) void CC
 bitmask_gfx__setpixel(struct video_gfx const *__restrict self,
                       video_coord_t x, video_coord_t y,
                       video_pixel_t pixel) {
-	struct bitmask_buffer *me = (struct bitmask_buffer *)self->vx_buffer;
+	struct old_bitmask_buffer *me = (struct old_bitmask_buffer *)self->vx_buffer;
 	uintptr_t bitoff = me->bmb_bm.vbm_skip + x + y * me->bmb_bm.vbm_scan;
 	byte_t mask, value, *bm = (byte_t *)me->bmb_bm.vbm_mask;
 	bm += bitoff >> 3;
@@ -145,7 +145,7 @@ bitmask_gfx_optimize(struct video_gfx *__restrict self) {
 	/* When no blending is being done, speed up color lookup by directly translating bits */
 	struct gfx_bitmaskdrv *drv = video_bitmaskgfx_getdrv(self);
 	if likely(drv->xsw_getcolor == &libvideo_swgfx_generic__getcolor_noblend) {
-		struct bitmask_buffer *me = (struct bitmask_buffer *)self->vx_buffer;
+		struct old_bitmask_buffer *me = (struct old_bitmask_buffer *)self->vx_buffer;
 		drv->xsw_getcolor = &bitmask_gfx__getcolor;
 		drv->gbmd_pal[0] = me->bmb_pal.vp_pal[0];
 		drv->gbmd_pal[1] = me->bmb_pal.vp_pal[1];
@@ -185,41 +185,39 @@ bitmask_initgfx(struct video_gfx *__restrict self) {
 
 
 
-#undef bitmask_ops
-PRIVATE struct video_buffer_ops bitmask_ops = {};
-INTERN ATTR_RETNONNULL WUNUSED struct video_buffer_ops const *CC _bitmask_ops(void) {
-	if unlikely(!bitmask_ops.vi_destroy) {
-		bitmask_ops.vi_rlock        = &bitmask_rlock;
-		bitmask_ops.vi_wlock        = &bitmask_wlock;
-		bitmask_ops.vi_unlock       = &libvideo_buffer_noop_unlock;
-		bitmask_ops.vi_rlockregion  = &bitmask_rlockregion;
-		bitmask_ops.vi_wlockregion  = &bitmask_wlockregion;
-		bitmask_ops.vi_unlockregion = &libvideo_buffer_noop_unlockregion;
-		bitmask_ops.vi_initgfx      = &bitmask_initgfx;
-		bitmask_ops.vi_updategfx    = &bitmask_updategfx;
+PRIVATE struct video_buffer_ops old_bitmask_ops = {};
+PRIVATE ATTR_RETNONNULL WUNUSED struct video_buffer_ops const *CC _old_bitmask_ops(void) {
+	if unlikely(!old_bitmask_ops.vi_destroy) {
+		old_bitmask_ops.vi_rlock        = &bitmask_rlock;
+		old_bitmask_ops.vi_wlock        = &bitmask_wlock;
+		old_bitmask_ops.vi_unlock       = &libvideo_buffer_noop_unlock;
+		old_bitmask_ops.vi_rlockregion  = &bitmask_rlockregion;
+		old_bitmask_ops.vi_wlockregion  = &bitmask_wlockregion;
+		old_bitmask_ops.vi_unlockregion = &libvideo_buffer_noop_unlockregion;
+		old_bitmask_ops.vi_initgfx      = &bitmask_initgfx;
+		old_bitmask_ops.vi_updategfx    = &bitmask_updategfx;
 		COMPILER_WRITE_BARRIER();
-		bitmask_ops.vi_destroy = &bitmask_destroy;
+		old_bitmask_ops.vi_destroy = &bitmask_destroy;
 		COMPILER_WRITE_BARRIER();
 	}
-	return &bitmask_ops;
+	return &old_bitmask_ops;
 }
-#define bitmask_ops (*_bitmask_ops())
 
 
-/* Initialize a "struct bitmask_buffer"
+/* Initialize a "struct old_bitmask_buffer"
  * @return: * : Always re-returns `self' */
-INTERN ATTR_RETNONNULL ATTR_OUT(1) ATTR_IN(4) ATTR_IN(5) struct bitmask_buffer *CC
-bitmask_buffer_init(struct bitmask_buffer *__restrict self,
-                    video_dim_t size_x, video_dim_t size_y,
-                    struct video_bitmask const *__restrict bm,
-                    video_color_t const bg_fg_colors[2]) {
+INTERN ATTR_RETNONNULL ATTR_OUT(1) ATTR_IN(4) ATTR_IN(5) struct old_bitmask_buffer *CC
+old_bitmask_buffer_init(struct old_bitmask_buffer *__restrict self,
+                        video_dim_t size_x, video_dim_t size_y,
+                        struct video_bitmask const *__restrict bm,
+                        video_color_t const bg_fg_colors[2]) {
 	memcpy(&self->bmb_bm, bm, sizeof(struct video_bitmask));
 	self->bmb_bm.vbm_mask = (byte_t const *)self->bmb_bm.vbm_mask + (self->bmb_bm.vbm_skip >> 3);
 	self->bmb_bm.vbm_skip &= 7;
 	self->bmb_pal.vp_cnt = 2;
 	self->bmb_pal.vp_pal[0] = bg_fg_colors[0];
 	self->bmb_pal.vp_pal[1] = bg_fg_colors[1];
-	self->vb_ops = &bitmask_ops;
+	self->vb_ops = _old_bitmask_ops();
 	self->vb_format.vf_codec = video_codec_lookup(VIDEO_CODEC_P1_MSB);
 	self->vb_format.vf_pal = video_palette_optimize((struct video_palette *)&self->bmb_pal); /* For "vp_color2pixel" */
 	assert(self->vb_format.vf_codec);
@@ -237,36 +235,6 @@ bitmask_buffer_init(struct bitmask_buffer *__restrict self,
 	return self;
 }
 
-
-/* Create a video buffer that represents the pixel data defined by  a
- * given `__bm' (bitmask). This function is primarily used internally
- * by `video_gfx_absfillmask()' and  `video_gfx_absfillstretchmask()'
- * to deal with  GFX contexts  where the bitmask  cannot be  rendered
- * using  the default method,  but has to be  rendered by being blit.
- *
- * @param: __size_x:       Width of the given `__bm' (in pixels)
- * @param: __size_y:       Height of the given `__bm' (in pixels)
- * @param: __bm:           Bitmask whose data should be referenced interpreted
- * @param: __bg_fg_colors: Colors that 0/1 bits of `__bm' should map to
- * @return: * :   The newly created video buffer
- * @return: NULL: [errno=ENOMEM] Insufficient memory (won't happen when
- *                               used internally, where struct is  just
- *                               allocated on-stack) */
-DEFINE_PUBLIC_ALIAS(video_buffer_forbitmask, libvideo_buffer_forbitmask);
-INTERN WUNUSED ATTR_IN(3) ATTR_IN(4) REF struct video_buffer *CC
-libvideo_buffer_forbitmask(video_dim_t size_x, video_dim_t size_y,
-                           struct video_bitmask const *__restrict bm,
-                           video_color_t const bg_fg_colors[2]) {
-	REF struct bitmask_buffer *result;
-	result = (REF struct bitmask_buffer *)malloc(sizeof(struct bitmask_buffer));
-	if likely(result) {
-		result = bitmask_buffer_init(result, size_x, size_y, bm, bg_fg_colors);
-		result->vb_refcnt = 1;
-		result->vb_domain = _libvideo_ramdomain();
-	}
-	return result;
-}
-
 DECL_END
 
 #endif /* !GUARD_LIBVIDEO_GFX_BUFFER_BITMASK_C */

kos/src/libvideo/gfx/buffer/bitmask.h kos/src/libvideo/gfx/buffer/old-bitmask.hkos/src/libvideo/gfx/buffer/bitmask.h renamed to kos/src/libvideo/gfx/buffer/old-bitmask.h

@@ -56,40 +56,20 @@ struct video_palette2 {
 };
 
 
-struct bitmask_buffer: video_buffer {
+struct old_bitmask_buffer: video_buffer {
 	struct video_bitmask  bmb_bm;  /* Bitmask representing this video buffer */
 	struct video_palette2 bmb_pal; /* Palette */
 };
 
 
-/* Initialize a "struct bitmask_buffer"
+/* Initialize a "struct old_bitmask_buffer"
  * @return: * : Always re-returns `self' */
-INTDEF ATTR_RETNONNULL ATTR_OUT(1) ATTR_IN(4) ATTR_IN(5) struct bitmask_buffer *CC
-bitmask_buffer_init(struct bitmask_buffer *__restrict self,
-                    video_dim_t size_x, video_dim_t size_y,
-                    struct video_bitmask const *__restrict bm,
-                    video_color_t const bg_fg_colors[2]);
-#define bitmask_buffer_fini(self) (void)0
-
-
-/* Create a video buffer that represents the pixel data defined by  a
- * given `__bm' (bitmask). This function is primarily used internally
- * by `video_gfx_absfillmask()' and  `video_gfx_absfillstretchmask()'
- * to deal with  GFX contexts  where the bitmask  cannot be  rendered
- * using  the default method,  but has to be  rendered by being blit.
- *
- * @param: __size_x:       Width of the given `__bm' (in pixels)
- * @param: __size_y:       Height of the given `__bm' (in pixels)
- * @param: __bm:           Bitmask whose data should be referenced interpreted
- * @param: __bg_fg_colors: Colors that 0/1 bits of `__bm' should map to
- * @return: * :   The newly created video buffer
- * @return: NULL: [errno=ENOMEM] Insufficient memory (won't happen when
- *                               used internally, where struct is  just
- *                               allocated on-stack) */
-INTDEF WUNUSED ATTR_IN(3) ATTR_IN(4) REF struct video_buffer *CC
-libvideo_buffer_forbitmask(video_dim_t size_x, video_dim_t size_y,
-                           struct video_bitmask const *__restrict bm,
-                           video_color_t const bg_fg_colors[2]);
+INTDEF ATTR_RETNONNULL ATTR_OUT(1) ATTR_IN(4) ATTR_IN(5) struct old_bitmask_buffer *CC
+old_bitmask_buffer_init(struct old_bitmask_buffer *__restrict self,
+                        video_dim_t size_x, video_dim_t size_y,
+                        struct video_bitmask const *__restrict bm,
+                        video_color_t const bg_fg_colors[2]);
+#define old_bitmask_buffer_fini(self) (void)0
 
 DECL_END
 

kos/src/libvideo/gfx/swgfx-hl.c

@@ -42,7 +42,7 @@ gcc_opt.append("-O3"); // Force _all_ optimizations because stuff in here is per
 #include <libvideo/gfx/gfx.h>
 #include <libvideo/types.h>
 
-#include "buffer/bitmask.h"
+#include "buffer/old-bitmask.h" /* TODO: Get rid of mask-fill operators */
 #include "gfx-empty.h"
 #include "gfx-utils.h"
 #include "swgfx.h"
@@ -329,11 +329,11 @@ libvideo_swgfx_fillmask_byblit(struct video_gfx const *__restrict self,
                                video_color_t const bg_fg_colors[2],
                                struct video_bitmask const *__restrict bm) {
 	struct video_gfx bm_gfx, *pgfx;
-	struct bitmask_buffer temp, *pbuf;
-	pbuf = bitmask_buffer_init(&temp, size_x, size_y, bm, bg_fg_colors);
+	struct old_bitmask_buffer temp, *pbuf;
+	pbuf = old_bitmask_buffer_init(&temp, size_x, size_y, bm, bg_fg_colors);
 	pgfx = video_buffer_getgfx(pbuf, &bm_gfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
 	video_gfx_bitblit(self, dst_x, dst_y, pgfx, 0, 0, size_x, size_y);
-	bitmask_buffer_fini(pbuf);
+	old_bitmask_buffer_fini(pbuf);
 }
 
 
@@ -345,12 +345,12 @@ libvideo_swgfx_fillstretchmask_byblit(struct video_gfx const *__restrict self,
                                       video_dim_t src_size_x, video_dim_t src_size_y,
                                       struct video_bitmask const *__restrict bm) {
 	struct video_gfx bm_gfx, *pgfx;
-	struct bitmask_buffer temp, *pbuf;
-	pbuf = bitmask_buffer_init(&temp, src_size_x, src_size_y, bm, bg_fg_colors);
+	struct old_bitmask_buffer temp, *pbuf;
+	pbuf = old_bitmask_buffer_init(&temp, src_size_x, src_size_y, bm, bg_fg_colors);
 	pgfx = video_buffer_getgfx(pbuf, &bm_gfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
 	video_gfx_stretch(self, dst_x, dst_y, dst_size_x, dst_size_y,
 	                  pgfx, 0, 0, src_size_x, src_size_y);
-	bitmask_buffer_fini(pbuf);
+	old_bitmask_buffer_fini(pbuf);
 }
 
 DECL_END