Implement new region video_buffer

Author: GrieferAtWork

kos/include/libvideo/gfx/buffer.h

@@ -381,8 +381,6 @@ struct video_buffer_ops {
 	                                               struct video_regionlock *__restrict __lock);
 
 
-	/* Buffer revocation / sub-region operators */
-
 	/* Revoke access to non-anonymous pixel data (and maybe even anonymous) of this video buffer.
 	 * Access  to pixel data of any sub-region created from `__self' (or recursively created form
 	 * one of those buffers) is also revoked.
@@ -528,6 +526,64 @@ video_buffer_wlockregion(struct video_buffer *__self, struct video_regionlock *_
  * by `video_buffer_rlockregion()' or `video_buffer_wlockregion()'. */
 extern __ATTR_INOUT(1) __ATTR_NONNULL((2)) void
 video_buffer_unlockregion(struct video_buffer *__self, struct video_regionlock *__lock);
+
+
+/* Revoke access to non-anonymous pixel data (and maybe even anonymous) of this video buffer.
+ * Access  to pixel data of any sub-region created from `__self' (or recursively created form
+ * one of those buffers) is also revoked.
+ *
+ * All types of video buffers can have their access revoked, except for buffers returned by
+ * `video_domain_newbuffer[_ex]()' (though sub-region buffers of those can be revoked,  and
+ * calling this function for one such buffer will do exactly that).
+ *
+ * @return: * : Always re-returns `__self' */
+extern __ATTR_RETNONNULL __ATTR_INOUT(1) struct video_buffer *
+__NOTHROW(video_buffer_revoke)(struct video_buffer *__restrict __self);
+
+/* Create a new hard subregion-proxy of `__self'. The caller is responsible to  ensure
+ * that the given `__rect' does not exceed `__self->vb_xdim' / `__self->vb_ydim'. Note
+ * that this function behaves slightly different from `video_buffer_region()', in that
+ * the  later accepts a signed rect, while also  allowing said rect to be greater than
+ * the dimensions of the original buffer.
+ *
+ * On the other hand, this function only works for creating **true** sub-rects, but
+ * since this one is implemented by individual buffers, it is probably faster, too.
+ *
+ * Buffers  returned by this function are guarantied  to share pixel access with `__self',
+ * and `video_buffer_revoke' is to `__self' will  also revoke access for `return'  (either
+ * directly, by keeping a list of sub-region buffers in `__self', or indirectly, by having
+ * every access to pixel-data in `return' check if `__self' has been revoked).
+ *
+ * NOTE: This function will never re-return `__self', even if `__rect' is the  full
+ *       rect of `__self', and `__xor_flags == 0'. This is because doing also cause
+ *       `video_buffer_revoke' invoked on the returned buffer to revoke `__self'.
+ *
+ * @assume(__rect->vcr_xdim > 0);
+ * @assume(__rect->vcr_ydim > 0);
+ * @assume((__rect->vcr_xmin + __rect->vcr_xdim) > __rect->vcr_xmin);
+ * @assume((__rect->vcr_ymin + __rect->vcr_ydim) > __rect->vcr_ymin);
+ * @assume((__rect->vcr_xmin + __rect->vcr_xdim) <= __self->vb_xdim);
+ * @assume((__rect->vcr_ymin + __rect->vcr_ydim) <= __self->vb_ydim);
+ * @param: __self: Video buffer to create a sub-region of
+ * @param: __rect: Sub-region rect of `__self' to-be returned
+ * @param: __xor_flags: Flags to xor- toggle in GFX contexts created on `return'.
+ *                      These flags are NOT applied  to `__rect', but they  still
+ *                      allow you to create  sub-region buffers that will  appear
+ *                      to be  natively rotated  in `struct video_gfx'  contexts.
+ *                      Only the following flags *should* be used here. All other
+ *                      flags can still be used, but many not necessarily produce
+ *                      expected results:
+ *                      - VIDEO_GFX_F_XMIRROR
+ *                      - VIDEO_GFX_F_YMIRROR
+ *                      - VIDEO_GFX_F_XYSWAP
+ * @return: * : The newly created sub-region buffer
+ * @return: NULL: [errno=ENOMEM] Insufficient memory
+ * @return: NULL: [errno=*] Failed to create sub-region for some other reason */
+extern __ATTR_WUNUSED __ATTR_INOUT(1) __ATTR_IN(2) __REF struct video_buffer *
+video_buffer_subregion(struct video_buffer *__restrict __self,
+                       struct video_crect const *__restrict __rect,
+                       gfx_flag_t __xor_flags);
+
 #else /* __INTELLISENSE__ */
 #define video_buffer_getgfx(self, result, blendmode, flags, colorkey)  \
 	((result)->vx_colorkey = (colorkey), (result)->vx_flags = (flags), \
@@ -549,6 +605,9 @@ video_buffer_unlockregion(struct video_buffer *__self, struct video_regionlock *
 	 (*(self)->vb_ops->vi_wlockregion)(self, lock))
 #define video_buffer_unlockregion(self, lock) \
 	(*(self)->vb_ops->vi_unlockregion)(self, lock)
+#define video_buffer_revoke(self) (*(self)->vb_ops->vi_revoke)(self)
+#define video_buffer_subregion(self, rect, xor_flags) \
+	(*(self)->vb_ops->vi_subregion)(self, rect, xor_flags)
 #endif /* !__INTELLISENSE__ */
 
 
@@ -785,6 +844,58 @@ video_buffer_lockable(struct video_buffer *__restrict __self);
 #endif /* LIBVIDEO_GFX_WANT_PROTOTYPES */
 
 
+
+/* Create a new region-relative-proxy of `__self', that interacts with the same
+ * pixel data, both during GFX operations,  as well when creating video  locks.
+ *
+ * You can also use  this function to create  regions at negative offsets,  or
+ * ones that are larger than `__self'. In this case, the returned buffer  will
+ * not be lockable, except when using `video_buffer_r/wlockregion' for regions
+ * that  contain actual pixel  data. Similarly, GFX  operations for pixel data
+ * outside  the true pixel area (which is enforced  by the I/O Rect of any GFX
+ * created using the returned  buffer), will yield "0"  during read, and be  a
+ * no-op during write.
+ *
+ * Then returned buffer always behaves properly when it comes to being able to
+ * be  revoked, after which point it will never again make any access to pixel
+ * data of `__self'.
+ *
+ * When the given `__rect' is actually a sub-region of `__self', then  this
+ * function will simply make use of `video_buffer_subregion()' and call the
+ * dedicated video buffer operator for creating sub-regions.
+ *
+ * When the returned buffer isn't created as a true sub-region of `__self',
+ * its  `vb_domain' will be set to the return value of `video_ramdomain()'.
+ *
+ * @param: __self: Video buffer to create a region of
+ * @param: __rect: region rect of `__self' to-be returned
+ * @param: __xor_flags: Flags to xor- toggle in GFX contexts created on  `return'.
+ *                      These flags are  NOT applied to  `__rect', but they  still
+ *                      allow  you to create region buffers that will appear to be
+ *                      natively  rotated in `struct video_gfx' contexts. Only the
+ *                      following flags *should* be used here. All other flags can
+ *                      still be used, but  many not necessarily produce  expected
+ *                      results:
+ *                      - VIDEO_GFX_F_XMIRROR
+ *                      - VIDEO_GFX_F_YMIRROR
+ *                      - VIDEO_GFX_F_XYSWAP
+ * @return: * : The newly created region buffer
+ * @return: NULL: [errno=ENOMEM] Insufficient memory
+ * @return: NULL: [errno=*] Failed to create region for some other reason */
+typedef __ATTR_WUNUSED_T __ATTR_INOUT_T(1) __ATTR_IN_T(2) __REF struct video_buffer *
+(LIBVIDEO_GFX_CC *PVIDEO_BUFFER_REGION)(struct video_buffer *__restrict __self,
+                                        struct video_rect const *__restrict __rect,
+                                        gfx_flag_t __xor_flags);
+#ifdef LIBVIDEO_GFX_WANT_PROTOTYPES
+LIBVIDEO_GFX_DECL __ATTR_WUNUSED __ATTR_INOUT(1) __ATTR_IN(2) __REF struct video_buffer *LIBVIDEO_GFX_CC
+video_buffer_region(struct video_buffer *__restrict __self,
+                    struct video_rect const *__restrict __rect,
+                    gfx_flag_t __xor_flags);
+#endif /* LIBVIDEO_GFX_WANT_PROTOTYPES */
+
+
+
+
 /* Return a video buffer that  will always (forcefully) re-return  `__self'
  * whenever a GFX context is requested. Additionally, video locks will fail
  * when pixels represented by `__self'  cannot represented as a video  lock

kos/include/libvideo/gfx/gfx.h

@@ -83,6 +83,12 @@ __DECL_BEGIN
 /* Set of `VIDEO_GFX_F*' */
 typedef __UINT32_TYPE__ gfx_flag_t;
 
+/* XXX: When  "old_flags & VIDEO_GFX_F_XYSWAP",  I  believe  we  have  to  swap
+ *      "more_flags & VIDEO_GFX_F_XMIRROR" / "more_flags & VIDEO_GFX_F_YMIRROR"
+ *      before they are XOR'd with `old_flags' */
+#define gfx_flag_combine(old_flags, more_flags) \
+	((old_flags) ^ (more_flags))
+
 struct video_buffer;
 struct video_gfxhdr;
 struct video_gfx;

kos/include/libvideo/rect.h

@@ -77,9 +77,9 @@ struct video_rect {
 
 /* Check if "a" and "b" intersect, and if so: store that intersection and return true */
 __LOCAL __ATTR_WUNUSED __ATTR_IN(1) __ATTR_IN(2) __ATTR_OUT(3) __BOOL
-video_rect_intersect(struct video_rect const *__restrict __a,
-                     struct video_rect const *__restrict __b,
-                     struct video_rect *__restrict __intersect) {
+video_rect_intersect(struct video_rect const *__a,
+                     struct video_rect const *__b,
+                     struct video_rect *__intersect) {
 	video_offset_t __a_xend = video_rect_getxend(__a);
 	video_offset_t __a_yend = video_rect_getyend(__a);
 	video_offset_t __b_xend = video_rect_getxend(__b);
@@ -99,9 +99,9 @@ video_rect_intersect(struct video_rect const *__restrict __a,
 
 /* Same as `video_rect_intersect()', but safely handles overflow in "__b" */
 __LOCAL __ATTR_WUNUSED __ATTR_IN(1) __ATTR_IN(2) __ATTR_OUT(3) __BOOL
-video_rect_intersect_overflow_in_b(struct video_rect const *__restrict __a,
-                                   struct video_rect const *__restrict __b,
-                                   struct video_rect *__restrict __intersect) {
+video_rect_intersect_overflow_in_b(struct video_rect const *__a,
+                                   struct video_rect const *__b,
+                                   struct video_rect *__intersect) {
 	video_offset_t __b_xend, __b_yend, __intersect_xend, __intersect_yend;
 	video_offset_t __a_xend = video_rect_getxend(__a);
 	video_offset_t __a_yend = video_rect_getyend(__a);
@@ -122,6 +122,32 @@ video_rect_intersect_overflow_in_b(struct video_rect const *__restrict __a,
 }
 
 
+__LOCAL __ATTR_WUNUSED __ATTR_IN(1) __ATTR_IN(2) __ATTR_OUT(3) __BOOL
+video_rect_intersect_overflow(struct video_rect const *__a,
+                              struct video_rect const *__b,
+                              struct video_rect *__intersect) {
+	video_offset_t __a_xend, __a_yend, __b_xend, __b_yend, __intersect_xend, __intersect_yend;
+	if (__hybrid_overflow_sadd(video_rect_getxmin(__a), video_rect_getxdim(__a), &__a_xend))
+		__a_xend = VIDEO_OFFSET_MAX;
+	if (__hybrid_overflow_sadd(video_rect_getymin(__a), video_rect_getydim(__a), &__a_yend))
+		__a_yend = VIDEO_OFFSET_MAX;
+	if (__hybrid_overflow_sadd(video_rect_getxmin(__b), video_rect_getxdim(__b), &__b_xend))
+		__b_xend = VIDEO_OFFSET_MAX;
+	if (__hybrid_overflow_sadd(video_rect_getymin(__b), video_rect_getydim(__b), &__b_yend))
+		__b_yend = VIDEO_OFFSET_MAX;
+	__intersect_xend = __hybrid_min(__a_xend, __b_xend);
+	__intersect_yend = __hybrid_min(__a_yend, __b_yend);
+	video_rect_setxmin(__intersect, __hybrid_max(video_rect_getxmin(__a), video_rect_getxmin(__b)));
+	video_rect_setymin(__intersect, __hybrid_max(video_rect_getymin(__a), video_rect_getymin(__b)));
+	if (video_rect_getxmin(__intersect) < __intersect_xend && video_rect_getymin(__intersect) < __intersect_yend) {
+		video_rect_setxend(__intersect, __intersect_xend);
+		video_rect_setyend(__intersect, __intersect_yend);
+		return 1;
+	}
+	return 0;
+}
+
+
 /* Update `__union' by adding `__addme' */
 __LOCAL __ATTR_INOUT(1) __ATTR_IN(2) void
 video_rect_union(struct video_rect *__restrict __union,

kos/src/libvideo/gfx/buffer.h

@@ -80,6 +80,29 @@ NOTHROW(FCC libvideo_buffer_noop_unlock)(struct video_buffer *__restrict self,
 	       (self)->vi_wlockregion  = &libvideo_buffer_notsup_wlockregion, \
 	       (self)->vi_unlockregion = &libvideo_buffer_noop_unlockregion)
 
+#define DEFINE_VIDEO_BUFFER_TYPE(name, vi_destroy_, vi_initgfx_, vi_updategfx_, vi_rlock_, vi_wlock_, \
+                                 vi_unlock_, vi_rlockregion_, vi_wlockregion_, vi_unlockregion_,      \
+                                 vi_revoke_, vi_subregion_)                                           \
+	INTERN struct video_buffer_ops name = {};                                                         \
+	INTERN ATTR_RETNONNULL WUNUSED struct video_buffer_ops const *CC _##name(void) {                  \
+		if unlikely(!name.vi_destroy) {                                                               \
+			name.vi_initgfx      = vi_initgfx_;                                                       \
+			name.vi_updategfx    = vi_updategfx_;                                                     \
+			name.vi_rlock        = vi_rlock_;                                                         \
+			name.vi_wlock        = vi_wlock_;                                                         \
+			name.vi_unlock       = vi_unlock_;                                                        \
+			name.vi_rlockregion  = vi_rlockregion_;                                                   \
+			name.vi_wlockregion  = vi_wlockregion_;                                                   \
+			name.vi_unlockregion = vi_unlockregion_;                                                  \
+			name.vi_revoke       = vi_revoke_;                                                        \
+			name.vi_subregion    = vi_subregion_;                                                     \
+			COMPILER_WRITE_BARRIER();                                                                 \
+			name.vi_destroy = &vi_destroy_;                                                           \
+			COMPILER_WRITE_BARRIER();                                                                 \
+		}                                                                                             \
+		return &name;                                                                                 \
+	}
+
 
 INTDEF WUNUSED ATTR_INOUT(1) ATTR_INOUT(2) int FCC
 libvideo_buffer_generic_rlockregion(struct video_buffer *__restrict self,

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

@@ -260,7 +260,7 @@ libvideo_buffer_forbitmask(video_dim_t size_x, video_dim_t size_y,
 	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();
+		result->vb_domain = _libvideo_ramdomain();
 	}
 	return result;
 }

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

@@ -261,7 +261,7 @@ libvideo_buffer_forcustom(video_dim_t size_x, video_dim_t size_y,
 	if (!(codec->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_PAL))
 		palette = NULL;
 	result->vb_ops             = _custom_ops();
-	result->vb_domain          = libvideo_ramdomain();
+	result->vb_domain          = _libvideo_ramdomain();
 	result->vb_format.vf_codec = codec;
 	result->vb_format.vf_pal   = palette;
 	if (palette)