Start removing the old ram-buffer system

Author: GrieferAtWork

kos/include/libvideo/gfx/buffer.h

@@ -917,54 +917,6 @@ old_video_buffer_fromgfx(struct video_gfx const *__restrict __self);
 #endif /* LIBVIDEO_GFX_WANT_PROTOTYPES */
 
 
-/* Create  a wrapper video buffer for `__self' that can only ever be used to access
- * the intersection of pixels from `__rect' and `__self' (trying a GFX context will
- * always  start out with the I/O rect set to "__rect", but the clip rect still set
- * to the buffer's base dimensions, and trying to lock OOB regions always fails)
- *
- * NOTE: Starting coords in `__rect' are allowed to be negative, and its dimensions
- *       are allowed to be greater than those of `__self', too!
- *
- * `old_video_buffer_region_revocable()' does the same, but the returned video buffer
- * is also "revocable" (s.a.  `old_video_buffer_region_revoke()'), meaning it can  be
- * detached  from the original buffer (and turned into  a no-op) at any point in time
- * (blocking if a video lock is held in `old_video_buffer_region_revoke()').
- *
- * @return: * :   The wrapper video buffer
- * @return: NULL: Failed to create video buffer (s.a. `errno') */
-typedef __ATTR_WUNUSED_T __ATTR_INOUT_T(1) __ATTR_IN_T(2) __REF struct video_buffer *
-(LIBVIDEO_GFX_CC *POLD_VIDEO_BUFFER_REGION)(struct video_buffer *__restrict __self,
-                                            struct video_rect const *__restrict __rect);
-typedef __ATTR_WUNUSED_T __ATTR_INOUT_T(1) __ATTR_IN_T(2) __REF struct video_buffer *
-(LIBVIDEO_GFX_CC *POLD_VIDEO_BUFFER_REGION_REVOCABLE)(struct video_buffer *__restrict __self,
-                                                      struct video_rect const *__restrict __rect);
-#ifdef LIBVIDEO_GFX_WANT_PROTOTYPES
-LIBVIDEO_GFX_DECL __ATTR_WUNUSED __ATTR_INOUT(1) __ATTR_IN(2) __REF struct video_buffer *LIBVIDEO_GFX_CC
-old_video_buffer_region(struct video_buffer *__restrict __self,
-                        struct video_rect const *__restrict __rect);
-LIBVIDEO_GFX_DECL __ATTR_WUNUSED __ATTR_INOUT(1) __ATTR_IN(2) __REF struct video_buffer *LIBVIDEO_GFX_CC
-old_video_buffer_region_revocable(struct video_buffer *__restrict __self,
-                                  struct video_rect const *__restrict __rect);
-#endif /* LIBVIDEO_GFX_WANT_PROTOTYPES */
-
-
-/* Revoke access  to  the  underlying video  buffer,  given  a  video
- * buffer that was returned by `old_video_buffer_region_revocable()'.
- * If the buffer had already been revoked, this is a no-op.
- *
- * >> DO NOT CALL THIS FUNCTION FOR BUFFERS OBTAINED FROM SOMETHING
- * >> OTHER THAN `old_video_buffer_region_revocable()' !!!
- *
- * @return: * : Always re-returns `__self' */
-typedef __ATTR_INOUT_T(1) struct video_buffer *
-(LIBVIDEO_GFX_CC *POLD_VIDEO_BUFFER_REGION_REVOKE)(struct video_buffer *__restrict __self);
-#ifdef LIBVIDEO_GFX_WANT_PROTOTYPES
-LIBVIDEO_GFX_DECL __ATTR_INOUT(1) struct video_buffer *LIBVIDEO_GFX_CC
-old_video_buffer_region_revoke(struct video_buffer *__restrict __self);
-#endif /* LIBVIDEO_GFX_WANT_PROTOTYPES */
-
-
-
 /* Various functions  for opening  a file/stream/blob  as an  image  file.
  * The actual file format is  auto-detected, and supported formats  depend
  * on installed 3rd party libraries. By default, BMP and PNG is supported. */

kos/src/apps/showpic/main.c

@@ -566,10 +566,10 @@ int main(int argc, char *argv[]) {
 		rect.vr_ymin = 100;
 		rect.vr_xdim = screen_buffer_asvideo(screen)->vb_xdim - 200;
 		rect.vr_ydim = screen_buffer_asvideo(screen)->vb_ydim - 200;
-		bscreen = old_video_buffer_region_revocable(screen_buffer_asvideo(screen), &rect);
+		bscreen = video_buffer_region(screen_buffer_asvideo(screen), &rect, 0);
 		if (!bscreen)
 			err(EXIT_FAILURE, "Failed to load screen buffer");
-//		old_video_buffer_region_revoke(bscreen);
+//		video_buffer_revoke(bscreen);
 	}
 #else
 	bscreen = screen_buffer_asvideo(screen);

kos/src/libvideo/compositor/compositor.c

@@ -233,7 +233,7 @@ try_convert_window_to_passthru(struct local_window *__restrict self) {
 	 *      become viewable, even if the window  is moved to be fully  on-screen) */
 
 	/* Allocate passthru buffer */
-	new_content = old_video_buffer_region_revocable(comp->lc_buffer, &self->lw_attr.vwa_rect);
+	new_content = video_buffer_region(comp->lc_buffer, &self->lw_attr.vwa_rect, 0);
 	if unlikely(!new_content)
 		return; /* Failed to allocate passthru buffer */
 
@@ -540,7 +540,7 @@ local_window_destroy(struct video_display *__restrict self) {
 	local_window_assert(me);
 	if (!(me->lw_attr.vwa_flags & VIDEO_WINDOW_F_HIDDEN)) {
 		if (LIST_ISBOUND(me, lw_passthru)) {
-			old_video_buffer_region_revoke(me->lw_content);
+			video_buffer_revoke(me->lw_content);
 			LIST_UNBIND(me, lw_passthru);
 		}
 		local_window_hide_impl(me);
@@ -1713,7 +1713,7 @@ _local_window_ensure_not_passthru_impl(struct local_window *__restrict self) {
 	self->lw_content = newbuf; /* Inherit reference (x2) */
 
 	/* Revoke video access and drop old buffer */
-	oldbuf = old_video_buffer_region_revoke(oldbuf);
+	oldbuf = video_buffer_revoke(oldbuf);
 	LIST_UNBIND(self, lw_passthru);
 	video_buffer_decref(oldbuf);
 	return 0;
@@ -2026,7 +2026,7 @@ local_compositor_newwindow(struct video_compositor *__restrict self,
 		    (result->lw_overlay_mask_allcount == 0)) {
 			/* Use a passthru buffer */
 			REF struct video_buffer *content;
-			content = old_video_buffer_region_revocable(comp->lc_buffer, &result->lw_attr.vwa_rect);
+			content = video_buffer_region(comp->lc_buffer, &result->lw_attr.vwa_rect, 0);
 			if unlikely(!content)
 				goto err_unlock_r_overlay;
 			result->lw_content = content;
@@ -2272,7 +2272,7 @@ local_compositor_setbuffer_locked(struct local_compositor *__restrict me,
 			REF struct video_buffer *new_passthru;
 			assert(LIST_ISBOUND(pt_window, lw_passthru));
 			local_window_assert(pt_window);
-			new_passthru = old_video_buffer_region_revocable(new_buffer, &pt_window->lw_attr.vwa_rect);
+			new_passthru = video_buffer_region(new_buffer, &pt_window->lw_attr.vwa_rect, 0);
 			if unlikely(!new_passthru) {
 				struct local_window *rollback;
 				/* Rollback already-allocated (new) passthru buffers */
@@ -2505,7 +2505,7 @@ local_compositor_setfeatures(struct video_compositor *__restrict self,
 			video_gfx_bitblit(&ngfx, 0, 0, &ogfx, 0, 0,
 			                  video_gfx_getclipw(&ngfx),
 			                  video_gfx_getcliph(&ngfx));
-			obuffer = old_video_buffer_region_revoke(obuffer);
+			obuffer = video_buffer_revoke(obuffer);
 			video_buffer_decref(obuffer);
 			LIST_UNBIND(pt_window, lw_passthru);
 		}

kos/src/libvideo/compositor/compositor.h

@@ -96,8 +96,8 @@ struct local_window: video_window {
 	struct video_window_attr   lw_attr;         /* [lock(local_window_comp(this)->lc_lock)] Window attributes (empty windows aren't allowed!) */
 	REF struct video_buffer   *lw_content;      /* [1..1][lock(local_window_comp(this)->lc_lock)]
 	                                             * - RGB/RGBA Content buffer (returned by `video_window_getbuffer()')
-	                                             * - Alternatively,  when  `lw_passthru' is  bound, this  is  a revocable  region in
-	                                             *   `local_window_comp(this)->lc_buffer' (s.a. `old_video_buffer_region_revoke()'). */
+	                                             * - Alternatively, when `lw_passthru' is bound, this is a revocable region in
+	                                             *   `local_window_comp(this)->lc_buffer'   (s.a.    `video_buffer_revoke()'). */
 	LIST_ENTRY(local_window)   lw_passthru;     /* [0..1][lock(local_window_comp(this)->lc_lock)] Entry in the list of windows with passthru buffers */
 	TAILQ_ENTRY(local_window)  lw_zorder;       /* [1..1][lock(local_window_comp(this)->lc_lock)] Entry in the list of all windows */
 	TAILQ_ENTRY(local_window)  lw_zorder_visi;  /* [0..1][lock(local_window_comp(this)->lc_lock)] Entry in the list of all visible windows */

kos/src/libvideo/gfx/buffer/lockable.c

@@ -44,9 +44,8 @@
 
 #include "../buffer.h"
 #include "../ramdomain.h"
-#include "old-gfx.h"
 #include "lockable.h"
-#include "old-ram.h"
+#include "region.h"
 
 DECL_BEGIN
 
@@ -56,24 +55,19 @@ DECL_BEGIN
 #define DBG_memset(p, c, n) (void)0
 #endif /* NDEBUG || NDEBUG_FINI */
 
-#undef LOCKABLE_BUFFER_PALREF
-#if 0
-#define LOCKABLE_BUFFER_PALREF
-#endif
-
 /* Indices into `struct video_lock::_vl_driver' */
 #define LOCKABLE_BUFFER_VLOCK_ISWRITE 0
 static_assert(_VIDEO_LOCK__N_DRIVER >= 1);
 
 /* Initialize a mock ram-buffer using the video lock of "self" */
 PRIVATE ATTR_OUT(1) ATTR_IN(2) void FCC
-lockable_asram(struct old_video_rambuffer *__restrict rb,
+lockable_asram(struct video_rambuffer_base *__restrict rb,
                struct lockable_buffer const *__restrict self) {
-	rb->vb_ops             = _old_rambuffer_ops();
-	rb->vb_format.vf_codec = self->vb_format.vf_codec;
-	rb->vb_format.vf_pal   = self->vb_format.vf_pal;
-	rb->vb_xdim            = self->vb_xdim;
-	rb->vb_ydim            = self->vb_ydim;
+	DBG_memset(&rb->vb_domain, 0xcc, sizeof(rb->vb_domain));
+	rb->vb_ops    = _rambuffer_ops();
+	rb->vb_format = self->vb_format;
+	rb->vb_xdim   = self->vb_xdim;
+	rb->vb_ydim   = self->vb_ydim;
 #ifndef NDEBUG
 	rb->vb_refcnt = 0; /* So someone incref'ing will fault */
 #endif /* !NDEBUG */
@@ -86,7 +80,7 @@ PRIVATE NONNULL((1)) void FCC
 lockable_readpixels(struct lockable_buffer const *__restrict self) {
 	struct video_gfx srcgfx, *p_srcgfx;
 	struct video_gfx dstgfx, *p_dstgfx;
-	struct old_video_rambuffer dst;
+	struct video_rambuffer_base dst;
 	lockable_asram(&dst, self);
 	p_srcgfx = video_buffer_getgfx(self->lb_base, &srcgfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
 	p_dstgfx = video_buffer_getgfx(&dst, &dstgfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
@@ -103,7 +97,7 @@ PRIVATE NONNULL((1)) void FCC
 lockable_writepixels(struct lockable_buffer const *__restrict self) {
 	struct video_gfx srcgfx, *p_srcgfx;
 	struct video_gfx dstgfx, *p_dstgfx;
-	struct old_video_rambuffer src;
+	struct video_rambuffer_base src;
 	lockable_asram(&src, self);
 	p_srcgfx = video_buffer_getgfx(&src, &srcgfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
 	p_dstgfx = video_buffer_getgfx(self->lb_base, &dstgfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
@@ -121,7 +115,7 @@ lockable_readpixels_region(struct lockable_buffer const *__restrict self,
                            struct video_regionlock const *__restrict region) {
 	struct video_gfx srcgfx, *p_srcgfx;
 	struct video_gfx dstgfx, *p_dstgfx;
-	struct old_video_rambuffer dst;
+	struct video_rambuffer_base dst;
 	lockable_asram(&dst, self);
 	p_srcgfx = video_buffer_getgfx(self->lb_base, &srcgfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
 	p_dstgfx = video_buffer_getgfx(&dst, &dstgfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
@@ -139,7 +133,7 @@ lockable_writepixels_region(struct lockable_buffer const *__restrict self,
                             struct video_regionlock const *__restrict region) {
 	struct video_gfx srcgfx, *p_srcgfx;
 	struct video_gfx dstgfx, *p_dstgfx;
-	struct old_video_rambuffer src;
+	struct video_rambuffer_base src;
 	lockable_asram(&src, self);
 	p_srcgfx = video_buffer_getgfx(&src, &srcgfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
 	p_dstgfx = video_buffer_getgfx(self->lb_base, &dstgfx, GFX_BLENDMODE_OVERRIDE, VIDEO_GFX_F_NORMAL, 0);
@@ -155,10 +149,8 @@ lockable_writepixels_region(struct lockable_buffer const *__restrict self,
 PRIVATE NONNULL((1)) void FCC
 lockable_destroy(struct video_buffer *__restrict self) {
 	struct lockable_buffer *me = (struct lockable_buffer *)self;
-#ifdef LOCKABLE_BUFFER_PALREF
 	if (me->vb_format.vf_pal)
 		video_palette_decref(me->vb_format.vf_pal);
-#endif /* LOCKABLE_BUFFER_PALREF */
 	video_buffer_decref(me->lb_base);
 	free(me->lb_data);
 	free(me);
@@ -352,19 +344,28 @@ PRIVATE ATTR_PURE WUNUSED ATTR_IN(1) bool CC
 video_buffer_islockable(struct video_buffer const *__restrict self) {
 	if (self->vb_ops == &lockable_ops)
 		goto yes;
-	if (self->vb_ops == &old_rambuffer_ops)
+	if (self->vb_ops == &rambuffer_ops)
+		goto yes;
+	if (self->vb_ops == &rambuffer_xcodec_ops)
+		goto yes;
+	if (self->vb_ops == &rambuffer_subregion_ops)
+		goto yes;
+	if (self->vb_ops == &rambuffer_subsubregion_ops)
 		goto yes;
-	if (self->vb_ops == &old_rambuffer_ops__for_codec)
+	if (self->vb_ops == &rambuffer_formem_ops)
 		goto yes;
-	if (self->vb_ops == &old_membuffer_ops)
+	if (self->vb_ops == &rambuffer_formem_xcodec_ops)
 		goto yes;
-	if (self->vb_ops == &old_membuffer_ops__for_codec)
+	if (self->vb_ops == &rambuffer_formem_subregion_ops)
 		goto yes;
-	if (self->vb_ops == &old_subregion_buffer_ops_norem) {
-		/* Subregion buffers are locked iff the underlying buffer is */
-		struct old_subregion_buffer const *me;
-		me = (struct old_subregion_buffer const *)self;
-		return video_buffer_islockable(me->srb_base);
+	if (self->vb_ops == &region_buffer_subregion_alias_ops) {
+		/* Region alias buffers are locked iff the underlying buffer is.
+		 * Note that other region buffers are never lockable, since they
+		 * always contain at least 1 pixel that is out-of-bounds of some
+		 * base buffer (meaning not **all** pixels are lockable) */
+		struct region_buffer_subregion_alias const *me;
+		me = (struct region_buffer_subregion_alias const *)self;
+		return video_buffer_islockable(me->rbf_base);
 	}
 	return false;
 yes:
@@ -379,7 +380,6 @@ video_buffer_islockable(struct video_buffer const *__restrict self) {
 INTERN WUNUSED ATTR_OUT(1) NONNULL((2)) struct video_buffer *CC
 libvideo_buffer_lockable_init(struct lockable_buffer *self,
                               struct video_buffer *__restrict buffer) {
-	self->lb_data = NULL;
 	if (video_buffer_islockable(buffer))
 		return buffer;
 	self->vb_ops    = _lockable_ops();
@@ -389,8 +389,9 @@ libvideo_buffer_lockable_init(struct lockable_buffer *self,
 #ifndef NDEBUG
 	self->vb_refcnt = 0;
 #endif /* !NDEBUG */
-	self->lb_base = buffer;
-	self->lb_data = NULL;
+	self->lb_base  = buffer;
+	self->lb_data  = NULL;
+	self->lb_edata = NULL;
 	DBG_memset(&self->lb_stride, 0xcc, sizeof(self->lb_stride));
 	return self;
 }
@@ -439,15 +440,14 @@ libvideo_buffer_lockable(struct video_buffer *__restrict self) {
 	result->vb_format = self->vb_format;
 	result->vb_xdim   = self->vb_xdim;
 	result->vb_ydim   = self->vb_ydim;
-	result->vb_domain = video_buffer_domain_for_wrapper(self);
+	result->vb_domain = _libvideo_ramdomain();
 	result->vb_refcnt = 1;
 	video_buffer_incref(self);
-	result->lb_base = self;
-	result->lb_data = NULL;
-#ifdef LOCKABLE_BUFFER_PALREF
+	result->lb_base  = self;
+	result->lb_data  = NULL;
+	result->lb_edata = NULL;
 	if (result->vb_format.vf_pal)
 		video_palette_incref(result->vb_format.vf_pal);
-#endif /* LOCKABLE_BUFFER_PALREF */
 	DBG_memset(&result->lb_stride, 0xcc, sizeof(result->lb_stride));
 	return result;
 err:

kos/src/libvideo/gfx/buffer/old-gfx.c

@@ -427,7 +427,7 @@ old_libvideo_buffer_fromgfx(struct video_gfx const *__restrict self) {
 			sr_result->vb_format = src->vb_format;
 			sr_result->vb_xdim   = self->vx_hdr.vxh_cxsiz;
 			sr_result->vb_ydim   = self->vx_hdr.vxh_cysiz;
-			sr_result->vb_domain = video_buffer_domain_for_wrapper(src);
+			sr_result->vb_domain = src->vb_domain;
 			sr_result->vb_refcnt = 1;
 			sr_result->srb_base  = src;
 			video_buffer_incref(src);
@@ -455,7 +455,7 @@ old_libvideo_buffer_fromgfx(struct video_gfx const *__restrict self) {
 	gx_result->vb_format = src->vb_format;
 	gx_result->vb_xdim   = self->vx_hdr.vxh_cxsiz;
 	gx_result->vb_ydim   = self->vx_hdr.vxh_cysiz;
-	gx_result->vb_domain = video_buffer_domain_for_wrapper(src);
+	gx_result->vb_domain = src->vb_domain;
 	gx_result->vb_refcnt = 1;
 	gx_result->gxb_base  = src;
 	video_buffer_incref(src);