Cleanup & minor fixes/improvements

Author: GrieferAtWork

kos/cpp.hint

@@ -2733,8 +2733,11 @@
 #define MPFR_DEPRECATED
 #define MPFR_RETURNS_NONNULL
 #define __MPC_DECLSPEC
-#define PARAMS(x) x
+#define PARAMS(p)p
 #define INLINE
+#define EXTERN(x)extern x
+#define JPP(p)p
+#define JMETHOD(T,n,p)T(*n)p
 
 
 

kos/include/libvideo/gfx/buffer.h

@@ -454,8 +454,8 @@ struct video_buffer_ops {
 	 * @assume(__lock->_vrl_rect.vcr_ydim > 0);
 	 * @assume((__lock->_vrl_rect.vcr_xmin + __lock->_vrl_rect.vcr_xdim) > __lock->_vrl_rect.vcr_xmin);
 	 * @assume((__lock->_vrl_rect.vcr_ymin + __lock->_vrl_rect.vcr_ydim) > __lock->_vrl_rect.vcr_ymin);
-	 * @assume((__lock->_vrl_rect.vcr_xmin + __lock->_vrl_rect.vcr_xdim) <= __self->vb_xdim);
-	 * @assume((__lock->_vrl_rect.vcr_ymin + __lock->_vrl_rect.vcr_ydim) <= __self->vb_ydim);
+	 * @assume((__lock->_vrl_rect.vcr_xmin + __lock->_vrl_rect.vcr_xdim) <= video_buffer_getxdim(__self));
+	 * @assume((__lock->_vrl_rect.vcr_ymin + __lock->_vrl_rect.vcr_ydim) <= video_buffer_getydim(__self));
 	 *
 	 * @return: 0:  Success
 	 * @return: -1: Error (s.a. `errno') */
@@ -472,8 +472,8 @@ struct video_buffer_ops {
 	 * @assume(__lock->_vrl_rect.vcr_ydim > 0);
 	 * @assume((__lock->_vrl_rect.vcr_xmin + __lock->_vrl_rect.vcr_xdim) > __lock->_vrl_rect.vcr_xmin);
 	 * @assume((__lock->_vrl_rect.vcr_ymin + __lock->_vrl_rect.vcr_ydim) > __lock->_vrl_rect.vcr_ymin);
-	 * @assume((__lock->_vrl_rect.vcr_xmin + __lock->_vrl_rect.vcr_xdim) <= __self->vb_xdim);
-	 * @assume((__lock->_vrl_rect.vcr_ymin + __lock->_vrl_rect.vcr_ydim) <= __self->vb_ydim);
+	 * @assume((__lock->_vrl_rect.vcr_xmin + __lock->_vrl_rect.vcr_xdim) <= video_buffer_getxdim(__self));
+	 * @assume((__lock->_vrl_rect.vcr_ymin + __lock->_vrl_rect.vcr_ydim) <= video_buffer_getydim(__self));
 	 *
 	 * @return: 0:  Success
 	 * @return: -1: Error (s.a. `errno') */
@@ -486,11 +486,11 @@ struct video_buffer_ops {
 	__NOTHROW_T(LIBVIDEO_GFX_FCC *vi_unlockregion)(struct video_buffer *__restrict __self,
 	                                               struct video_regionlock *__restrict __lock);
 
-	/* 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_surface_region()', in that
-	 * the later accepts a signed  rect, while also allowing said  rect to be greater  than
-	 * the dimensions of the original buffer.
+	/* Create a new hard subregion-proxy of `__self'. The caller is responsible to ensure
+	 * that the given  `__rect' does not  exceed `video_buffer_get[xy]dim(__self)'.  Note
+	 * that this function  behaves slightly different  from `video_surface_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.
@@ -613,8 +613,8 @@ video_buffer_unlock(struct video_buffer *__self, struct video_lock *__lock);
  * @assume(__ydim > 0);
  * @assume((__xmin + __xdim) > __xmin);
  * @assume((__ymin + __ydim) > __ymin);
- * @assume((__xmin + __xdim) <= __self->vb_xdim);
- * @assume((__ymin + __ydim) <= __self->vb_ydim);
+ * @assume((__xmin + __xdim) <= video_buffer_getxdim(__self));
+ * @assume((__ymin + __ydim) <= video_buffer_getydim(__self));
  *
  * @return: 0:  Success
  * @return: -1: Error (s.a. `errno') */
@@ -632,8 +632,8 @@ video_buffer_rlockregion(struct video_buffer *__self, struct video_regionlock *_
  * @assume(__ydim > 0);
  * @assume((__xmin + __xdim) > __xmin);
  * @assume((__ymin + __ydim) > __ymin);
- * @assume((__xmin + __xdim) <= __self->vb_xdim);
- * @assume((__ymin + __ydim) <= __self->vb_ydim);
+ * @assume((__xmin + __xdim) <= video_buffer_getxdim(__self));
+ * @assume((__ymin + __ydim) <= video_buffer_getydim(__self));
  *
  * @return: 0:  Success
  * @return: -1: Error (s.a. `errno') */
@@ -755,24 +755,41 @@ struct video_buffer {
 
 /* Acquire/release references to sub-objects that any (initialized) buffer must hold */
 #ifdef LIBVIDEO_GFX_EXPOSE_INTERNALS
-#define __video_buffer_setsubregion(self, parent_surface, parent_buffer) \
-	(void)((self)->vb_surf.vs_pal      = (parent_surface)->vs_pal,       \
-	       (self)->vb_surf.vs_flags    = (parent_surface)->vs_flags,     \
-	       (self)->vb_surf.vs_colorkey = (parent_surface)->vs_colorkey,  \
-	       (self)->vb_codec            = (parent_buffer)->vb_codec)
-#define __video_buffer_setformat(self, format)                   \
-	(void)((self)->vb_surf.vs_pal      = (format)->vbf_pal,      \
-	       (self)->vb_surf.vs_flags    = (format)->vbf_flags,    \
-	       (self)->vb_surf.vs_colorkey = (format)->vbf_colorkey, \
-	       (self)->vb_codec            = (format)->vbf_codec)
+/* Initialize format of `self' from `format'
+ * @return: true:  Success
+ * @return: false: Error: missing palette */
+#define __video_buffer_init_format(self, format)                                           \
+	((self)->vb_surf.vs_pal      = (format)->vbf_pal,                                      \
+	 (self)->vb_surf.vs_flags    = (format)->vbf_flags,                                    \
+	 (self)->vb_surf.vs_colorkey = (format)->vbf_colorkey,                                 \
+	 (((self)->vb_codec = (format)->vbf_codec)->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_PAL) \
+	 ? ((self)->vb_surf.vs_pal != __NULLPTR)                                               \
+	 : ((self)->vb_surf.vs_pal = __NULLPTR, (self)->vb_surf.vs_flags &= ~VIDEO_GFX_F_PALOBJ, 1))
+#define __video_buffer_init_domain(self, domain) \
+	(void)((self)->vb_domain = (domain))
+/* Initialize dimensions of a buffer */
+#define __video_buffer_init_dim(self, xdim, ydim) \
+	(void)((self)->vb_xdim = (xdim), (self)->vb_ydim = (ydim))
+/* Initialize format+domain+dim for a subregion buffer */
+#define __video_buffer_init_subregion(self, parent_surface, parent_buffer, rect) \
+	(void)((self)->vb_surf.vs_pal      = (parent_surface)->vs_pal,               \
+	       (self)->vb_surf.vs_flags    = (parent_surface)->vs_flags,             \
+	       (self)->vb_surf.vs_colorkey = (parent_surface)->vs_colorkey,          \
+	       (self)->vb_codec            = (parent_buffer)->vb_codec,              \
+	       (self)->vb_domain           = (parent_buffer)->vb_domain,             \
+	       __video_buffer_init_dim(self, (rect)->vcr_xdim, (rect)->vcr_ydim))
+/* Initialize operators of a buffer */
+#define __video_buffer_init_ops(self, ops) \
+	(void)((self)->vb_ops = (ops))
 #ifdef __INTELLISENSE__
 #define __video_buffer_init_common(self) ((self)->vb_surf.vs_buffer = (self))
 #define __video_buffer_fini_common(self) (void)((self)->vb_surf.vs_buffer = (self))
 #else /* __INTELLISENSE__ */
 #define __video_buffer_init_common(self)                 \
 	(!((self)->vb_surf.vs_flags & VIDEO_GFX_F_PALOBJ) || \
 	 (video_palette_incref((self)->vb_surf.vs_pal), 0),  \
-	 video_codec_incref((self)->vb_codec), (self)->vb_surf.vs_buffer = (self))
+	 video_codec_incref((self)->vb_codec),               \
+	 (self)->vb_refcnt = 1, (self)->vb_surf.vs_buffer = (self))
 #define __video_buffer_fini_common(self)                         \
 	(void)(__hybrid_assert((self)->vb_surf.vs_buffer == (self)), \
 	       video_codec_decref((self)->vb_codec),                 \

kos/include/libvideo/gfx/gfx.h

@@ -1198,7 +1198,7 @@ struct video_gfxhdr {
 	 * - VIDEO_GFX_F_XMIRROR/*Y mirror the "I/O Rect"
 	 *
 	 * Coords of these rects are (in absolute "video_coord_t" coords):
-	 * - Buffer:    {xy: {0,0}, wh: {vx_surf.vs_buffer->vb_xdim,vx_surf.vs_buffer->vb_ydim}}
+	 * - Buffer:    {xy: {0,0}, wh: video_buffer_getXYdim(vx_surf.vs_buffer)}
 	 * - Clip Rect: {xy: {vxh_cxoff,vxh_cyoff}, wh: {vxh_cxdim,vxh_cydim}}
 	 * - I/O Rect:  {xy: {vxh_bxmin,vxh_bymin}, wh: {vxh_bxsiz,vxh_bysiz}}
 	 *
@@ -1253,8 +1253,8 @@ struct video_gfxhdr {
 	 * NOTE: The I/O Rect is already pre-adjusted for VIDEO_GFX_F_XMIRROR/VIDEO_GFX_F_YMIRROR */
 	video_coord_t               vxh_bxmin;    /* [<= vxh_bxend][>= vxh_cxoff] Absolute buffer start coord in X (start of acc) */
 	video_coord_t               vxh_bymin;    /* [<= vxh_byend][>= vxh_cyoff] Absolute buffer start coord in Y */
-	video_coord_t               vxh_bxend;    /* [<= vx_surf.vs_buffer->vb_xdim] Absolute buffer end coord in X (<= `vx_surf.vs_buffer->vb_xdim') */
-	video_coord_t               vxh_byend;    /* [<= vx_surf.vs_buffer->vb_ydim] Absolute buffer end coord in Y (<= `vx_surf.vs_buffer->vb_ydim') */
+	video_coord_t               vxh_bxend;    /* [<= video_buffer_getxdim(:vx_surf.vs_buffer)] Absolute buffer end coord in X */
+	video_coord_t               vxh_byend;    /* [<= video_buffer_getydim(:vx_surf.vs_buffer)] Absolute buffer end coord in Y */
 //	video_dim_t                 vxh_bxdim;    /* [== vxh_bxend - vxh_bxmin][<= vxh_cxdim] I/O Rect width */
 //	video_dim_t                 vxh_bydim;    /* [== vxh_byend - vxh_bymin][<= vxh_cydim] I/O Rect height */
 };

kos/include/libvideo/gfx/surface.h

@@ -210,11 +210,11 @@ video_surface_getgfx(struct video_surface const *__self,
                      struct video_gfx *__result,
                      gfx_blendmode_t __blendmode);
 
-/* 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_surface_region()', in that
- * the later accepts a signed  rect, while also allowing said  rect to be greater  than
- * the dimensions of the original buffer.
+/* Create a new hard subregion-proxy of `__self'. The caller is responsible to ensure
+ * that the given `__rect'  does not exceed `video_surface_get[xy]dim(__self)'.  Note
+ * that this function  behaves slightly different  from `video_surface_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.

kos/src/apps/showpic/main.c

@@ -562,8 +562,8 @@ int main(int argc, char *argv[]) {
 		struct video_rect rect;
 		rect.vr_xmin = 100;
 		rect.vr_ymin = 100;
-		rect.vr_xdim = screen_buffer_asvideo(screen)->vb_xdim - 200;
-		rect.vr_ydim = screen_buffer_asvideo(screen)->vb_ydim - 200;
+		rect.vr_xdim = video_buffer_getxdim(screen_buffer_asvideo(screen)) - 200;
+		rect.vr_ydim = video_buffer_getydim(screen_buffer_asvideo(screen)) - 200;
 		bscreen = video_buffer_region(screen_buffer_asvideo(screen), &rect);
 		if (!bscreen)
 			err(EXIT_FAILURE, "Failed to load screen buffer");
@@ -643,7 +643,7 @@ int main(int argc, char *argv[]) {
 #endif
 
 	/* Load the named file as a video buffer. */
-	anim = video_anim_open(bscreen->vb_domain, argv[1]);
+	anim = video_anim_open(video_buffer_getdomain(bscreen), argv[1]);
 	if unlikely(!anim)
 		err(EXIT_FAILURE, "Failed to open image");
 
@@ -657,7 +657,7 @@ int main(int argc, char *argv[]) {
 	{
 		struct video_buffer_format format;
 		video_buffer_getformat(bscreen, &format);
-		anim = video_anim_cached(anim, bscreen->vb_domain, &format);
+		anim = video_anim_cached(anim, video_buffer_getdomain(bscreen), &format);
 	}
 #endif
 

kos/src/libvideo/compositor/compositor.c

@@ -2229,14 +2229,10 @@ add_alpha(struct video_codec *__restrict codec) {
 PRIVATE ATTR_INOUT(1) void CC
 local_compositor_updatebuffercaches(struct local_compositor *__restrict me) {
 	struct video_buffer *buffer = me->lc_buffer;
-
-	me->lc_domain                  = buffer->vb_domain;
-	me->lc_nalpha_format.vbf_codec = video_buffer_getcodec(buffer);
-	me->lc_nalpha_format.vbf_pal   = buffer->vb_surf.vs_pal;
-	me->lc_nalpha_format.vbf_flags = video_buffer_getflags(buffer) & ~VIDEO_GFX_F_COLORKEY;
-	me->lc_yalpha_format.vbf_codec = add_alpha(video_buffer_getcodec(buffer));
-	me->lc_yalpha_format.vbf_pal   = buffer->vb_surf.vs_pal;
-	me->lc_yalpha_format.vbf_flags = me->lc_nalpha_format.vbf_flags;
+	me->lc_domain = video_buffer_getdomain(buffer);
+	video_buffer_getformat(buffer, &me->lc_nalpha_format);
+	me->lc_yalpha_format = me->lc_nalpha_format;
+	me->lc_yalpha_format.vbf_codec = add_alpha(me->lc_yalpha_format.vbf_codec);
 
 	/* Generate new (pre-cached) GFX contexts */
 	DBG_memset(&me->lc_buffer_gfx_write, 0xcc, sizeof(me->lc_buffer_gfx_write));

kos/src/libvideo/gfx/anim.c

@@ -115,9 +115,9 @@ libvideo_anim_fromframe(struct video_buffer *__restrict frame) {
 	if unlikely(!result)
 		goto err;
 	result->va_ops    = _oneframe_anim_ops();
-	result->va_domain = frame->vb_domain;
-	result->va_xdim   = frame->vb_xdim;
-	result->va_ydim   = frame->vb_ydim;
+	result->va_domain = video_buffer_getdomain(frame);
+	result->va_xdim   = video_buffer_getxdim(frame);
+	result->va_ydim   = video_buffer_getydim(frame);
 	result->va_refcnt = 1;
 	result->ofa_frame = frame;
 	video_buffer_incref(frame);
@@ -430,7 +430,7 @@ libvideo_anim_cached(struct video_anim *__restrict self,
 		REF struct video_buffer *converted;
 		struct oneframe_anim *me = (struct oneframe_anim *)self;
 		struct video_buffer *frame = me->ofa_frame;
-		if (frame->vb_domain == domain &&
+		if (video_buffer_getdomain(frame) == domain &&
 		    (!format || video_buffer_hasformat(frame, format))) {
 			video_anim_incref(me);
 			return me;

kos/src/libvideo/gfx/buffer.h

@@ -35,23 +35,27 @@
 
 DECL_BEGIN
 
-#define video_regionlock_assert(self, lock)                                                            \
-	(__assertf(((lock)->_vrl_rect.vcr_xmin + (lock)->_vrl_rect.vcr_xdim) > (lock)->_vrl_rect.vcr_xmin, \
-	           "video_regionlock: X+SX overflows, or SX=0 [X=%" PRIuCRD ",SX=%" PRIuDIM "]",           \
-	           (lock)->_vrl_rect.vcr_xmin, (lock)->_vrl_rect.vcr_xdim),                                \
-	 __assertf(((lock)->_vrl_rect.vcr_ymin + (lock)->_vrl_rect.vcr_ydim) > (lock)->_vrl_rect.vcr_ymin, \
-	           "video_regionlock: Y+SY overflows, or SY=0 [Y=%" PRIuCRD ",SY=%" PRIuDIM "]",           \
-	           (lock)->_vrl_rect.vcr_ymin, (lock)->_vrl_rect.vcr_ydim),                                \
-	 __assertf(((lock)->_vrl_rect.vcr_xmin + (lock)->_vrl_rect.vcr_xdim) <= (self)->vb_xdim,           \
-	           "video_regionlock: X+SX overflows exceeds buffer dimension "                            \
-	           "[X=%" PRIuCRD ",SX=%" PRIuDIM ",X+SX=%" PRIuDIM ",DIM=%" PRIuDIM "]",                  \
-	           (lock)->_vrl_rect.vcr_xmin, (lock)->_vrl_rect.vcr_xdim,                                 \
-	           (lock)->_vrl_rect.vcr_xmin + (lock)->_vrl_rect.vcr_xdim, (self)->vb_xdim),              \
-	 __assertf(((lock)->_vrl_rect.vcr_ymin + (lock)->_vrl_rect.vcr_ydim) <= (self)->vb_ydim,           \
-	           "video_regionlock: Y+SY overflows exceeds buffer dimension "                            \
-	           "[Y=%" PRIuCRD ",SY=%" PRIuDIM ",Y+SY=%" PRIuDIM ",DIM=%" PRIuDIM "]",                  \
-	           (lock)->_vrl_rect.vcr_ymin, (lock)->_vrl_rect.vcr_ydim,                                 \
-	           (lock)->_vrl_rect.vcr_ymin + (lock)->_vrl_rect.vcr_ydim, (self)->vb_ydim))
+#define _video_buffer_assert_rect(context, self, rect)                                \
+	(__assertf(((rect)->vcr_xmin + (rect)->vcr_xdim) > (rect)->vcr_xmin,              \
+	           context ": X+SX overflows, or SX=0 [X=%" PRIuCRD ",SX=%" PRIuDIM "]",  \
+	           (rect)->vcr_xmin, (rect)->vcr_xdim),                                   \
+	 __assertf(((rect)->vcr_ymin + (rect)->vcr_ydim) > (rect)->vcr_ymin,              \
+	           context ": Y+SY overflows, or SY=0 [Y=%" PRIuCRD ",SY=%" PRIuDIM "]",  \
+	           (rect)->vcr_ymin, (rect)->vcr_ydim),                                   \
+	 __assertf(((rect)->vcr_xmin + (rect)->vcr_xdim) <= video_buffer_getxdim(self),   \
+	           context ": X+SX overflows exceeds buffer dimension "                   \
+	           "[X=%" PRIuCRD ",SX=%" PRIuDIM ",X+SX=%" PRIuDIM ",DIM=%" PRIuDIM "]", \
+	           (rect)->vcr_xmin, (rect)->vcr_xdim,                                    \
+	           (rect)->vcr_xmin + (rect)->vcr_xdim, video_buffer_getxdim(self)),      \
+	 __assertf(((rect)->vcr_ymin + (rect)->vcr_ydim) <= video_buffer_getydim(self),   \
+	           context ": Y+SY overflows exceeds buffer dimension "                   \
+	           "[Y=%" PRIuCRD ",SY=%" PRIuDIM ",Y+SY=%" PRIuDIM ",DIM=%" PRIuDIM "]", \
+	           (rect)->vcr_ymin, (rect)->vcr_ydim,                                    \
+	           (rect)->vcr_ymin + (rect)->vcr_ydim, video_buffer_getydim(self)))
+#define video_buffer_assert_rect(self, rect) \
+	_video_buffer_assert_rect("assert_rect", self, rect)
+#define video_regionlock_assert(self, lock) \
+	_video_buffer_assert_rect("video_regionlock", self, &(lock)->_vrl_rect)
 
 /* Generic implementations for video buffer operators. */
 INTDEF ATTR_RETNONNULL ATTR_INOUT(1) struct video_gfx *FCC