Cleanup & minor improvements

GrieferAtWork · GrieferAtWork · commit 9d4671aa6a83 · 2025-07-25T22:21:53.000+02:00
diff --git a/kos/include/libsvgadrv/chipset.h b/kos/include/libsvgadrv/chipset.h
@@ -165,6 +165,7 @@ typedef __ATTR_NONNULL_T((2, 3)) __ssize_t
 
 
 struct svga_palette_color {
+	/* TODO: Instead of this, just use `video_color_t' (so libvideo doesn't have to use an intermediate buffer) */
 	__uint8_t spc_r; /* Red */
 	__uint8_t spc_g; /* Green */
 	__uint8_t spc_b; /* Blue */
diff --git a/kos/include/libvideo/gfx/gfx.h b/kos/include/libvideo/gfx/gfx.h
@@ -1259,9 +1259,6 @@ struct video_gfxhdr {
 //	video_dim_t                 vxh_bydim;    /* [== vxh_byend - vxh_bymin][<= vxh_cydim] I/O Rect height */
 };
 
-#define _video_gfxhdr_bxsiz(self) ((self)->vxh_bxend - (self)->vxh_bxmin)
-#define _video_gfxhdr_bysiz(self) ((self)->vxh_byend - (self)->vxh_bymin)
-
 struct video_gfx {
 	struct video_surface vx_surf;  /* Video surface with which to interact. */
 	/* TODO: Rename "video_gfxhdr" to something like "video_gfxclip" (and also rename `vx_hdr' to `vx_clip') */
diff --git a/kos/src/libvideo/gfx/buffer/custom.c b/kos/src/libvideo/gfx/buffer/custom.c
@@ -197,7 +197,7 @@ custom_buffer__subregion_impl(struct video_surface const *__restrict surface,
 	__video_buffer_init_subregion(result, surface, parent, rect);
 	result->cbsr_xoff = parent_xoff + rect->vcr_xmin;
 	result->cbsr_yoff = parent_yoff + rect->vcr_ymin;
-	video_codec_xcoord_to_offset(result->vb_codec, result->cbsr_xoff,
+	video_codec_xcoord_to_offset(video_buffer_getcodec(result), result->cbsr_xoff,
 	                             &result->cbsr_bxoff, &result->cbsr_bxrem);
 	result->vb_ops = !result->cbsr_xoff && !result->cbsr_yoff
 	                 ? _custom_buffer_subregion_nooff_ops()
@@ -364,7 +364,7 @@ custom_buffer__rlockregion(struct video_buffer *__restrict self,
 	if (rlock) {
 		int result;
 		size_t xoff;
-		video_codec_xcoord_to_offset(me->vb_codec,
+		video_codec_xcoord_to_offset(video_buffer_getcodec(me),
 		                             lock->_vrl_rect.vcr_xmin,
 		                             &xoff, &lock->vrl_xbas);
 		result = (*rlock)(me->cbc_cookie, &lock->vrl_lock);
@@ -400,7 +400,7 @@ custom_buffer__wlockregion(struct video_buffer *__restrict self,
 	if (wlock) {
 		int result;
 		size_t xoff;
-		video_codec_xcoord_to_offset(me->vb_codec,
+		video_codec_xcoord_to_offset(video_buffer_getcodec(me),
 		                             lock->_vrl_rect.vcr_xmin,
 		                             &xoff, &lock->vrl_xbas);
 		result = (*wlock)(me->cbc_cookie, &lock->vrl_lock);
@@ -426,7 +426,7 @@ NOTHROW(FCC custom_buffer__unlockregion)(struct video_buffer *__restrict self,
 	} else if (me->cbc_unlock) {
 		size_t xoff;
 		video_coord_t xrem;
-		video_codec_xcoord_to_offset(self->vb_codec,
+		video_codec_xcoord_to_offset(video_buffer_getcodec(self),
 		                             lock->_vrl_rect.vcr_xmin,
 		                             &xoff, &xrem);
 		assert(xrem == lock->vrl_xbas);
diff --git a/kos/src/libvideo/gfx/buffer/lockable.c b/kos/src/libvideo/gfx/buffer/lockable.c
@@ -151,9 +151,8 @@ lockable_buffer__subregion_impl(struct video_surface const *__restrict surface,
 	result->lb_stride = self->lb_stride;
 	result->lb_data += base_yoff * result->lb_stride;
 	result->lb_data += base_yoff * result->lb_stride;
-	video_codec_xcoord_to_offset(result->vb_codec, base_xoff,
-	                             &result->lbsb_bxoff,
-	                             &result->lbsb_bxrem);
+	video_codec_xcoord_to_offset(video_buffer_getcodec(result), base_xoff,
+	                             &result->lbsb_bxoff, &result->lbsb_bxrem);
 	result->lbsb_xoff     = base_xoff;
 	result->lbsb_yoff     = base_yoff;
 	result->lbsb_lockable = self;
@@ -732,7 +731,7 @@ lockable_buffer_subregion__initgfx(struct video_gfx *__restrict self) {
 INTERN ATTR_PURE WUNUSED ATTR_IN(1) bool CC
 libvideo_buffer_islockable(struct video_buffer const *__restrict self) {
 	/* List of RAM-domain buffers that are known to always be lockable */
-	if (self->vb_domain == &libvideo_ramdomain) {
+	if (video_buffer_getdomain(self) == &libvideo_ramdomain) {
 		if (self->vb_ops == &lockable_buffer_ops)
 			goto yes;
 		if (self->vb_ops == &lockable_buffer_subregion_norem_ops)
diff --git a/kos/src/libvideo/gfx/buffer/region.c b/kos/src/libvideo/gfx/buffer/region.c
@@ -215,8 +215,9 @@ INTERN ATTR_RETNONNULL ATTR_INOUT(1) struct video_gfx *FCC
 region_buffer__initgfx(struct video_gfx *__restrict self) {
 	struct region_buffer *me = (struct region_buffer *)video_gfx_getbuffer(self);
 	self = (*(self->vx_surf.vs_buffer = me->rbf_base)->vb_ops->vi_initgfx)(self);
-	return (*self->vx_hdr.vxh_ops->vgfo_clip)(self, me->rbf_cxoff, me->rbf_cyoff,
-	                                          video_buffer_getxdim(me), video_buffer_getydim(me));
+	return video_gfx_clip(self, me->rbf_cxoff, me->rbf_cyoff,
+	                      video_buffer_getxdim(me),
+	                      video_buffer_getydim(me));
 }
 
 
diff --git a/kos/src/libvideo/gfx/display.c b/kos/src/libvideo/gfx/display.c
@@ -103,7 +103,7 @@ libvideo_display_forbuffer(struct video_buffer *__restrict buffer) {
 	result = (REF struct dummy_display *)malloc(sizeof(struct dummy_display));
 	if unlikely(!result)
 		goto err;
-	result->vd_domain = buffer->vb_domain;
+	result->vd_domain = video_buffer_getdomain(buffer);
 	result->vd_ops    = _dummy_display_ops();
 	result->vd_refcnt = 1;
 	result->dd_buffer = buffer;
diff --git a/kos/src/libvideo/gfx/gfx-palettize.c b/kos/src/libvideo/gfx/gfx-palettize.c
@@ -242,8 +242,8 @@ hist_palettize(struct video_gfx const *__restrict self,
 
 	/* Check if the histogram is usable */
 	if (fail_if_too_many_bins) {
-		video_dim_t io_sx = _video_gfxhdr_bxsiz(&self->vx_hdr);
-		video_dim_t io_sy = _video_gfxhdr_bysiz(&self->vx_hdr);
+		video_dim_t io_sx = video_gfx_getioxdim(self);
+		video_dim_t io_sy = video_gfx_getioydim(self);
 		size_t io_pixels  = (size_t)io_sx * io_sy;
 		video_pixel_t i;
 		size_t pal_pixels = 0;
@@ -265,8 +265,8 @@ hist_palettize(struct video_gfx const *__restrict self,
 		video_pixel_t i;
 		uint64_t pal_pixels_adj;
 		size_t pal_pixels = 0;
-		video_dim_t io_sx = _video_gfxhdr_bxsiz(&self->vx_hdr);
-		video_dim_t io_sy = _video_gfxhdr_bysiz(&self->vx_hdr);
+		video_dim_t io_sx = video_gfx_getioxdim(self);
+		video_dim_t io_sy = video_gfx_getioydim(self);
 		size_t io_pixels  = (size_t)io_sx * io_sy;
 		for (i = 0; i < palsize; ++i) {
 			video_color_t c = h->h_colors[i].hb_color;
@@ -471,7 +471,7 @@ PRIVATE WUNUSED ATTR_PURE video_color_t LIBVIDEO_GFX_FCC
 median_io_gfx(void const *cookie, mc_index_t i) {
 	/* Fallback median-cut I/O callback using direct GFX color reads (slow) */
 	struct video_gfx const *self = (struct video_gfx const *)cookie;
-	video_dim_t io_sx = _video_gfxhdr_bxsiz(&self->vx_hdr);
+	video_dim_t io_sx = video_gfx_getioxdim(self);
 	video_coord_t y = self->vx_hdr.vxh_bymin + (i / io_sx);
 	video_coord_t x = self->vx_hdr.vxh_bxmin + (i % io_sx);
 	/* TODO: Check that "self" is SW-based */
@@ -490,10 +490,10 @@ median_cut_start(struct video_gfx const *__restrict self,
                  video_color_t constant_alpha) {
 	struct median_io io;
 	if (video_gfx_issurfio(self) &&
-	    /* TODO: This actually works for any XXXX8888 codec. Just need  to
-	     *       "video_gfx_getbuffer(self)->vb_codec->vc_color2pixel" the
-	     *       produced  palette entries afterwards, and always pass the
-	     *       codec's alpha-mask instead of "constant_alpha". */
+	    /* TODO: This actually works for any XXXX8888 codec. Just need to
+	     *       "video_gfx_getcodec(self)->vc_color2pixel" the  produced
+	     *       palette  entries afterwards, and always pass the codec's
+	     *       alpha-mask instead of "constant_alpha". */
 	    video_gfx_getcodec(self)->vc_codec == VIDEO_CODEC_RGBA8888) {
 		struct video_lock lock;
 		if (video_buffer_rlock(video_gfx_getbuffer(self), &lock) == 0) {
@@ -537,8 +537,8 @@ median_cut_palettize(struct video_gfx const *__restrict self,
 	 *       its speed against mine (maybe mine just sucks?)
 	 * TODO: Live with median_cut being slow, and adjust documentation accordingly. */
 	mc_index_t i, io_pixels, *gfx_indices;
-	video_dim_t io_sx = _video_gfxhdr_bxsiz(&self->vx_hdr);
-	video_dim_t io_sy = _video_gfxhdr_bysiz(&self->vx_hdr);
+	video_dim_t io_sx = video_gfx_getioxdim(self);
+	video_dim_t io_sy = video_gfx_getioydim(self);
 	shift_t pal_depth;
 	if (OVERFLOW_UMUL(io_sx, io_sy, &io_pixels)) {
 		errno = EOVERFLOW;
diff --git a/kos/src/libvideo/gfx/gfx.c b/kos/src/libvideo/gfx/gfx.c
@@ -219,22 +219,22 @@ libvideo_gfx_offset2coord__generic(struct video_gfx const *__restrict self,
                                    video_offset_t x, video_offset_t y,
                                    video_coord_t coords[2]) {
 	if (video_gfx_getflags(self) & VIDEO_GFX_F_XMIRROR)
-		x = (self->vx_hdr.vxh_cxdim - 1) - x;
+		x = (video_gfx_getclipxdim(self) - 1) - x;
 	if (video_gfx_getflags(self) & VIDEO_GFX_F_YMIRROR)
-		y = (self->vx_hdr.vxh_cydim - 1) - y;
+		y = (video_gfx_getclipydim(self) - 1) - y;
 	if (video_gfx_getflags(self) & VIDEO_GFX_F_XWRAP)
-		x = wrap(x, self->vx_hdr.vxh_cxdim);
+		x = wrap(x, video_gfx_getclipxdim(self));
 	if (video_gfx_getflags(self) & VIDEO_GFX_F_YWRAP)
-		x = wrap(x, self->vx_hdr.vxh_cxdim);
-	x += self->vx_hdr.vxh_cxoff;
-	y += self->vx_hdr.vxh_cyoff;
-	if unlikely((video_coord_t)x < self->vx_hdr.vxh_bxmin)
+		y = wrap(y, video_gfx_getclipydim(self));
+	x += video_gfx_getclipxmin(self);
+	y += video_gfx_getclipymin(self);
+	if unlikely((video_coord_t)x < video_gfx_getioxmin(self))
 		goto fail;
-	if unlikely((video_coord_t)y < self->vx_hdr.vxh_bymin)
+	if unlikely((video_coord_t)y < video_gfx_getioymin(self))
 		goto fail;
-	if unlikely((video_coord_t)x >= self->vx_hdr.vxh_bxend)
+	if unlikely((video_coord_t)x >= video_gfx_getioxend(self))
 		goto fail;
-	if unlikely((video_coord_t)y >= self->vx_hdr.vxh_byend)
+	if unlikely((video_coord_t)y >= video_gfx_getioyend(self))
 		goto fail;
 	if (video_gfx_getflags(self) & VIDEO_GFX_F_XYSWAP) {
 		video_offset_t temp;
@@ -265,20 +265,20 @@ libvideo_gfx_coord2offset__generic(struct video_gfx const *__restrict self,
 		x    = y;
 		y    = temp;
 	}
-	if unlikely(x < self->vx_hdr.vxh_bxmin)
+	if unlikely(x < video_gfx_getioxmin(self))
 		goto fail;
-	if unlikely(y < self->vx_hdr.vxh_bymin)
+	if unlikely(y < video_gfx_getioymin(self))
 		goto fail;
-	if unlikely(x >= self->vx_hdr.vxh_bxend)
+	if unlikely(x >= video_gfx_getioxend(self))
 		goto fail;
-	if unlikely(y >= self->vx_hdr.vxh_byend)
+	if unlikely(y >= video_gfx_getioyend(self))
 		goto fail;
-	x -= self->vx_hdr.vxh_cxoff;
-	y -= self->vx_hdr.vxh_cyoff;
+	x -= video_gfx_getclipxmin(self);
+	y -= video_gfx_getclipymin(self);
 	if (video_gfx_getflags(self) & VIDEO_GFX_F_XMIRROR)
-		x = (self->vx_hdr.vxh_cxdim - 1) - x;
+		x = (video_gfx_getclipxdim(self) - 1) - x;
 	if (video_gfx_getflags(self) & VIDEO_GFX_F_YMIRROR)
-		y = (self->vx_hdr.vxh_cydim - 1) - y;
+		y = (video_gfx_getclipydim(self) - 1) - y;
 	offsets[0] = (video_offset_t)x;
 	offsets[1] = (video_offset_t)y;
 	return true;
diff --git a/kos/src/libvideo/gfx/io.c b/kos/src/libvideo/gfx/io.c
@@ -126,7 +126,7 @@ frame2anim(REF struct video_buffer *frame) {
 PRIVATE WUNUSED NONNULL((1, 2)) REF struct video_buffer *CC
 convert_to_wanted_domain(struct video_domain const *__restrict domain,
                          /*inherit(always)*/ REF struct video_buffer *__restrict self) {
-	if unlikely(self->vb_domain != domain) {
+	if unlikely(video_buffer_getdomain(self) != domain) {
 		REF struct video_buffer *converted;
 		struct video_buffer_format result_format;
 		video_buffer_getformat(self, &result_format);
diff --git a/kos/src/libvideo/gfx/io/bmp.c.inl b/kos/src/libvideo/gfx/io/bmp.c.inl
@@ -194,11 +194,11 @@ fix_missing_alpha_channel(struct video_buffer *__restrict self) {
 	};
 	video_coord_t y;
 	struct video_rambuffer *me = (struct video_rambuffer *)self;
-	assert(me->vb_domain == &libvideo_ramdomain);
+	assert(video_buffer_getdomain(me) == &libvideo_ramdomain);
 	assert(me->vb_ops == &rambuffer_ops ||
 	       me->vb_ops == &rambuffer_formem_ops);
-	assert(me->vb_codec->vc_codec == VIDEO_CODEC_RGBA8888);
-	assert(me->vb_surf.vs_pal == NULL);
+	assert(video_buffer_getcodec(me)->vc_codec == VIDEO_CODEC_RGBA8888);
+	assert(video_buffer_getpalette(me) == NULL);
 	for (y = 0; y < video_buffer_getydim(me); ++y) {
 		struct pixel *iter, *end;
 		iter = (struct pixel *)(me->rb_data + y * me->rb_stride);
diff --git a/kos/src/libvideo/gfx/io/gif.c.inl b/kos/src/libvideo/gfx/io/gif.c.inl
@@ -606,7 +606,7 @@ gif_anim_paintframe(struct gif_anim const *__restrict anim,
 	}
 
 	/* Check if we need to convert from a palette-based output buffer to a direct-color one */
-	codec = frame->vb_codec;
+	codec = video_buffer_getcodec(frame);
 	if ((self->gb_lct != lct) &&
 	    (codec->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_PAL) &&
 	    /* When the old frame gets disposed, then we also don't need DCOL mode */
@@ -702,7 +702,7 @@ err_dcol_buffer:
 		assert(self->vaf_frame == frame);
 		video_buffer_decref(frame);            /* Decref old (palette) frame */
 		self->vaf_frame = frame = dcol_buffer; /* Inherit reference */
-		codec = frame->vb_codec;
+		codec = video_buffer_getcodec(frame);
 	} else {
 		if unlikely(video_buffer_wlock(frame, &frame_lock))
 			goto err;
diff --git a/kos/src/libvideo/gfx/ramdomain-gfx.c b/kos/src/libvideo/gfx/ramdomain-gfx.c
@@ -60,7 +60,7 @@ rambuffer__initgfx_common(struct video_gfx *__restrict self) {
 	static_assert(sizeof(struct gfx_ramdrv) <= (_VIDEO_GFX_N_DRIVER * sizeof(void *)));
 	struct video_rambuffer *me = (struct video_rambuffer *)video_gfx_getbuffer(self);
 	struct gfx_ramdrv *drv = video_ramgfx_getdrv(self);
-	drv->grd_codec  = me->vb_codec;
+	drv->grd_codec  = video_buffer_getcodec(me);
 	drv->grd_stride = me->rb_stride;
 	drv->grd_data   = me->rb_data;
 
@@ -70,7 +70,7 @@ rambuffer__initgfx_common(struct video_gfx *__restrict self) {
 
 	/* Load optimized pixel accessors if applicable to the loaded format. */
 #ifdef CONFIG_HAVE_RAMBUFFER_PIXELn_FASTPASS
-	switch (me->vb_codec->vc_specs.vcs_bpp) {
+	switch (video_buffer_getcodec(me)->vc_specs.vcs_bpp) {
 	case 8:
 		drv->xsw_setpixel = &ramgfx__setpixel8;
 		drv->xsw_getpixel = &ramgfx__getpixel8;
@@ -114,7 +114,7 @@ rambuffer__initgfx_common(struct video_gfx *__restrict self) {
 	}
 
 	/* Special optimization for "VIDEO_CODEC_RGBA8888": no color conversion needed */
-	if (me->vb_codec->vc_codec == VIDEO_CODEC_RGBA8888) {
+	if (video_buffer_getcodec(me)->vc_codec == VIDEO_CODEC_RGBA8888) {
 		if (drv->xsw_getcolor == &ramgfx__getcolor)
 			drv->xsw_getcolor = drv->xsw_getpixel;
 		if (drv->xsw_putcolor == &ramgfx__putcolor_noblend) {
diff --git a/kos/src/libvideo/gfx/ramdomain.c b/kos/src/libvideo/gfx/ramdomain.c
@@ -135,7 +135,7 @@ rambuffer__subregion__common(struct video_surface const *__restrict surface,
 	if unlikely(!result)
 		goto err;
 	__video_buffer_init_subregion(result, surface, self, rect);
-	video_codec_xcoord_to_offset(result->vb_codec, rect->vcr_xmin,
+	video_codec_xcoord_to_offset(video_buffer_getcodec(result), rect->vcr_xmin,
 	                             &x_byte_offset, &result->rbs_bxrem);
 	__video_buffer_init_ops(result, result->rbs_bxrem ? _rambuffer_subregion_ops()
 	                                                  : _rambuffer_subregion_norem_ops());
@@ -285,9 +285,9 @@ libvideo_ramdomain_formem(struct video_domain const *__restrict self,
 	}
 
 	/* Must use a different, fallback "codec" that can deal with bad alignment */
-	if (!IS_ALIGNED(stride, result->vb_codec->vc_align) ||
-	    !IS_ALIGNED((uintptr_t)mem, result->vb_codec->vc_align))
-		result->vb_codec = result->vb_codec->vc_nalgn;
+	if (!IS_ALIGNED(stride, video_buffer_getcodec(result)->vc_align) ||
+	    !IS_ALIGNED((uintptr_t)mem, video_buffer_getcodec(result)->vc_align))
+		result->vb_codec = video_buffer_getcodec(result)->vc_nalgn;
 
 	/* Validate palette configuration */
 	__video_buffer_init_domain(result, self);
diff --git a/kos/src/libvideo/gfx/swgfx-hl-blit.c b/kos/src/libvideo/gfx/swgfx-hl-blit.c
@@ -150,16 +150,16 @@ libvideo_swgfx_blitfrom(struct video_blitter *__restrict ctx) {
 		if (video_gfx_hascolorkey(src_gfx)) {
 			/* TODO */
 		}
-		if (noblend_blit_compatible(dst_buffer->vb_codec,
-		                            src_buffer->vb_codec) &&
-		    src_buffer->vb_surf.vs_pal == dst_buffer->vb_surf.vs_pal) {
+		if (noblend_blit_compatible(video_buffer_getcodec(dst_buffer),
+		                            video_buffer_getcodec(src_buffer)) &&
+			video_gfx_getpalette(src_gfx) == video_gfx_getpalette(dst_gfx)) {
 			/* Special optimization when not doing any blending, and both GFX contexts
 			 * share the same codec: in this case,  we can try to directly copy  pixel
 			 * data, either through video locks, or by directly reading/writing pixels */
 			drv->bsw_blit         = &libvideo_swblitter_noblend_samefmt__blit;
 			drv->bsw_blit_imatrix = &libvideo_swblitter_noblend_samefmt__blit_imatrix;
 			if (video_gfx_getflags(src_gfx) & VIDEO_GFX_F_LINEAR) {
-				if (src_buffer->vb_codec->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_INTERP8888) {
+				if (video_buffer_getcodec(src_buffer)->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_INTERP8888) {
 					drv->bsw_stretch         = &libvideo_swblitter_noblend_samefmt_interp8888__stretch_l;
 					drv->bsw_stretch_imatrix = &libvideo_swblitter_noblend_samefmt_interp8888__stretch_imatrix_l;
 				} else {
@@ -180,7 +180,7 @@ libvideo_swgfx_blitfrom(struct video_blitter *__restrict ctx) {
 			drv->bsw_blit         = &libvideo_swblitter_noblend_difffmt__blit;
 			drv->bsw_blit_imatrix = &libvideo_swblitter_noblend_difffmt__blit_imatrix;
 			if (video_gfx_getflags(src_gfx) & VIDEO_GFX_F_LINEAR) {
-				if (src_buffer->vb_codec->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_INTERP8888) {
+				if (video_buffer_getcodec(src_buffer)->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_INTERP8888) {
 					drv->bsw_stretch         = &libvideo_swblitter_noblend_difffmt_interp8888__stretch_l;
 					drv->bsw_stretch_imatrix = &libvideo_swblitter_noblend_difffmt_interp8888__stretch_imatrix_l;
 				} else {
@@ -265,7 +265,7 @@ libvideo_swgfx_blitfrom3(struct video_blitter3 *__restrict ctx) {
 			}
 		} else if (GFX_BLENDMODE_GET_MODE(wrdst_gfx->vx_blend) == GFX_BLENDMODE_ALPHA &&
 		           GFX_BLENDMODE_GET_MODE(rddst_gfx->vx_blend) == GFX_BLENDMODE_ALPHAMASK &&
-		           rddst_gfx->vx_surf.vs_buffer->vb_codec->vc_codec == VIDEO_CODEC_A1_MSB) {
+		           video_gfx_getcodec(rddst_gfx)->vc_codec == VIDEO_CODEC_A1_MSB) {
 			/* Special optimization for bitmasked alpha-blending.
 			 * In this mode, only pixels masked by the given bitmask get blended
 			 * into the `wrdst_gfx' GFX, with all other pixels being left as-is. */
@@ -286,8 +286,8 @@ libvideo_swgfx_blitfrom3(struct video_blitter3 *__restrict ctx) {
 				/* Since the source has no alpha, it always produces colors with A=255.
 				 * As such, the alpha-blending that happens in `wrdst_gfx' would  never
 				 * consider data from existing pixels, meaning blending can be skipped. */
-				if (src_gfx->vx_surf.vs_buffer->vb_codec == wrdst_gfx->vx_surf.vs_buffer->vb_codec &&
-				    src_gfx->vx_surf.vs_buffer->vb_surf.vs_pal == wrdst_gfx->vx_surf.vs_buffer->vb_surf.vs_pal) {
+				if (video_gfx_getcodec(src_gfx) == video_gfx_getcodec(wrdst_gfx) &&
+				    video_gfx_getpalette(src_gfx) == video_gfx_getpalette(wrdst_gfx)) {
 					/* Same-codec+pal -> don't have to convert between pixel formats */
 					drv->bsw3_blit         = &libvideo_swblitter3__blit__mask1msb_blend1_samefmt;
 					drv->bsw3_blit_imatrix = &libvideo_swblitter3__blit_imatrix__mask1msb_blend1_samefmt;
diff --git a/kos/src/libvideo/gfx/swgfx.h b/kos/src/libvideo/gfx/swgfx.h
@@ -964,7 +964,7 @@ libvideo_swgfx_update(struct video_gfx *__restrict self, unsigned int what) {
 	 * - drv->xsw_getcolor */
 	if (what & (VIDEO_GFX_UPDATE_FLAGS | VIDEO_GFX_UPDATE_COLORKEY)) {
 		/* Select how colors should be read. */
-		if (video_gfx_getbuffer(self)->vb_codec->vc_codec == VIDEO_CODEC_RGBA8888) {
+		if (video_gfx_getcodec(self)->vc_codec == VIDEO_CODEC_RGBA8888) {
 			/* Special optimization for "VIDEO_CODEC_RGBA8888": no color conversion needed */
 			drv->xsw_getcolor = drv->xsw_getpixel;
 		} else {
@@ -1004,7 +1004,7 @@ libvideo_swgfx_update(struct video_gfx *__restrict self, unsigned int what) {
 			/* No blending is being done -> link operators that try to make use of direct memory access. */
 
 			/* Special optimization for "VIDEO_CODEC_RGBA8888": no color conversion needed */
-			if (video_gfx_getbuffer(self)->vb_codec->vc_codec == VIDEO_CODEC_RGBA8888) {
+			if (video_gfx_getcodec(self)->vc_codec == VIDEO_CODEC_RGBA8888) {
 				drv->xsw_putcolor = drv->xsw_setpixel;
 			} else {
 				drv->xsw_putcolor = &libvideo_swgfx_generic__putcolor_noblend;
@@ -1013,7 +1013,7 @@ libvideo_swgfx_update(struct video_gfx *__restrict self, unsigned int what) {
 			drv->xsw_absline_h   = &libvideo_swgfx_noblend__absline_h;
 			drv->xsw_absline_v   = &libvideo_swgfx_noblend__absline_v;
 			drv->xsw_absfill     = &libvideo_swgfx_noblend__absfill;
-			if (video_gfx_getbuffer(self)->vb_codec->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_INTERP8888) {
+			if (video_gfx_getcodec(self)->vc_specs.vcs_flags & VIDEO_CODEC_FLAG_INTERP8888) {
 				drv->xsw_absgradient   = &libvideo_swgfx_noblend_interp8888__absgradient;
 				drv->xsw_absgradient_h = &libvideo_swgfx_noblend_interp8888__absgradient_h;
 				drv->xsw_absgradient_v = &libvideo_swgfx_noblend_interp8888__absgradient_v;
diff --git a/kos/src/libvideo/gfx/swgfx/hl_blit-nowrap.c.inl b/kos/src/libvideo/gfx/swgfx/hl_blit-nowrap.c.inl
diff --git a/kos/src/libvideo/gfx/swgfx/hl_blit.c.inl b/kos/src/libvideo/gfx/swgfx/hl_blit.c.inl
diff --git a/kos/src/libvideo/gfx/swgfx/ll_blit.c.inl b/kos/src/libvideo/gfx/swgfx/ll_blit.c.inl
diff --git a/kos/src/libvideo/gfx/swgfx/ll_noblend-blit.c.inl b/kos/src/libvideo/gfx/swgfx/ll_noblend-blit.c.inl
