WebSVN – Kolibri OS – Blame – /drivers/video/Gallium/auxiliary/util/u_format_yuv.c

Rev	Author	Line No.	Line
3770	Serge	1	/**************************************************************************
		2	*
		3	* Copyright 2010 VMware, Inc.
		4	* All Rights Reserved.
		5	*
		6	* Permission is hereby granted, free of charge, to any person obtaining a
		7	* copy of this software and associated documentation files (the
		8	* "Software"), to deal in the Software without restriction, including
		9	* without limitation the rights to use, copy, modify, merge, publish,
		10	* distribute, sub license, and/or sell copies of the Software, and to
		11	* permit persons to whom the Software is furnished to do so, subject to
		12	* the following conditions:
		13	*
		14	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		15	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		16	* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
		17	* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
		18	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
		19	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
		20	* USE OR OTHER DEALINGS IN THE SOFTWARE.
		21	*
		22	* The above copyright notice and this permission notice (including the
		23	* next paragraph) shall be included in all copies or substantial portions
		24	* of the Software.
		25	*
		26	**************************************************************************/
		27
		28
		29	/**
		30	* @file
		31	* YUV and RGB subsampled formats conversion.
		32	*
		33	* @author Jose Fonseca
		34	*/
		35
		36
		37	#include "util/u_debug.h"
		38	#include "util/u_format_yuv.h"
		39
		40
		41	void
		42	util_format_r8g8_b8g8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		43	const uint8_t *src_row, unsigned src_stride,
		44	unsigned width, unsigned height)
		45	{
		46	unsigned x, y;
		47
		48	for (y = 0; y < height; y += 1) {
		49	float *dst = dst_row;
		50	const uint32_t src = (const uint32_t )src_row;
		51	uint32_t value;
		52	float r, g0, g1, b;
		53
		54	for (x = 0; x + 1 < width; x += 2) {
		55	value = *src++;
		56
		57	#ifdef PIPE_ARCH_BIG_ENDIAN
		58	value = util_bswap32(value);
		59	#endif
		60
		61	r = ubyte_to_float((value >> 0) & 0xff);
		62	g0 = ubyte_to_float((value >> 8) & 0xff);
		63	b = ubyte_to_float((value >> 16) & 0xff);
		64	g1 = ubyte_to_float((value >> 24) & 0xff);
		65
		66	dst[0] = r; /* r */
		67	dst[1] = g0; /* g */
		68	dst[2] = b; /* b */
		69	dst[3] = 1.0f; /* a */
		70	dst += 4;
		71
		72	dst[0] = r; /* r */
		73	dst[1] = g1; /* g */
		74	dst[2] = b; /* b */
		75	dst[3] = 1.0f; /* a */
		76	dst += 4;
		77	}
		78
		79	if (x < width) {
		80	value = *src;
		81
		82	#ifdef PIPE_ARCH_BIG_ENDIAN
		83	value = util_bswap32(value);
		84	#endif
		85
		86	r = ubyte_to_float((value >> 0) & 0xff);
		87	g0 = ubyte_to_float((value >> 8) & 0xff);
		88	b = ubyte_to_float((value >> 16) & 0xff);
		89	g1 = ubyte_to_float((value >> 24) & 0xff);
		90
		91	dst[0] = r; /* r */
		92	dst[1] = g0; /* g */
		93	dst[2] = b; /* b */
		94	dst[3] = 1.0f; /* a */
		95	}
		96
		97	src_row += src_stride/sizeof(*src_row);
		98	dst_row += dst_stride/sizeof(*dst_row);
		99	}
		100	}
		101
		102
		103	void
		104	util_format_r8g8_b8g8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		105	const uint8_t *src_row, unsigned src_stride,
		106	unsigned width, unsigned height)
		107	{
		108	unsigned x, y;
		109
		110	for (y = 0; y < height; y += 1) {
		111	uint8_t *dst = dst_row;
		112	const uint32_t src = (const uint32_t )src_row;
		113	uint32_t value;
		114	uint8_t r, g0, g1, b;
		115
		116	for (x = 0; x + 1 < width; x += 2) {
		117	value = *src++;
		118
		119	#ifdef PIPE_ARCH_BIG_ENDIAN
		120	value = util_bswap32(value);
		121	#endif
		122
		123	r = (value >> 0) & 0xff;
		124	g0 = (value >> 8) & 0xff;
		125	b = (value >> 16) & 0xff;
		126	g1 = (value >> 24) & 0xff;
		127
		128	dst[0] = r; /* r */
		129	dst[1] = g0; /* g */
		130	dst[2] = b; /* b */
		131	dst[3] = 0xff; /* a */
		132	dst += 4;
		133
		134	dst[0] = r; /* r */
		135	dst[1] = g1; /* g */
		136	dst[2] = b; /* b */
		137	dst[3] = 0xff; /* a */
		138	dst += 4;
		139	}
		140
		141	if (x < width) {
		142	value = *src;
		143
		144	#ifdef PIPE_ARCH_BIG_ENDIAN
		145	value = util_bswap32(value);
		146	#endif
		147
		148	r = (value >> 0) & 0xff;
		149	g0 = (value >> 8) & 0xff;
		150	b = (value >> 16) & 0xff;
		151	g1 = (value >> 24) & 0xff;
		152
		153	dst[0] = r; /* r */
		154	dst[1] = g0; /* g */
		155	dst[2] = b; /* b */
		156	dst[3] = 0xff; /* a */
		157	}
		158
		159	src_row += src_stride/sizeof(*src_row);
		160	dst_row += dst_stride/sizeof(*dst_row);
		161	}
		162	}
		163
		164
		165	void
		166	util_format_r8g8_b8g8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		167	const float *src_row, unsigned src_stride,
		168	unsigned width, unsigned height)
		169	{
		170	unsigned x, y;
		171
		172	for (y = 0; y < height; y += 1) {
		173	const float *src = src_row;
		174	uint32_t dst = (uint32_t )dst_row;
		175	float r, g0, g1, b;
		176	uint32_t value;
		177
		178	for (x = 0; x + 1 < width; x += 2) {
		179	r = 0.5f*(src[0] + src[4]);
		180	g0 = src[1];
		181	g1 = src[5];
		182	b = 0.5f*(src[2] + src[6]);
		183
		184	value = float_to_ubyte(r);
		185	value \|= float_to_ubyte(g0) << 8;
		186	value \|= float_to_ubyte(b) << 16;
		187	value \|= float_to_ubyte(g1) << 24;
		188
		189	#ifdef PIPE_ARCH_BIG_ENDIAN
		190	value = util_bswap32(value);
		191	#endif
		192
		193	*dst++ = value;
		194
		195	src += 8;
		196	}
		197
		198	if (x < width) {
		199	r = src[0];
		200	g0 = src[1];
		201	g1 = 0;
		202	b = src[2];
		203
		204	value = float_to_ubyte(r);
		205	value \|= float_to_ubyte(g0) << 8;
		206	value \|= float_to_ubyte(b) << 16;
		207	value \|= float_to_ubyte(g1) << 24;
		208
		209	#ifdef PIPE_ARCH_BIG_ENDIAN
		210	value = util_bswap32(value);
		211	#endif
		212
		213	*dst = value;
		214	}
		215
		216	dst_row += dst_stride/sizeof(*dst_row);
		217	src_row += src_stride/sizeof(*src_row);
		218	}
		219	}
		220
		221
		222	void
		223	util_format_r8g8_b8g8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		224	const uint8_t *src_row, unsigned src_stride,
		225	unsigned width, unsigned height)
		226	{
		227	unsigned x, y;
		228
		229	for (y = 0; y < height; y += 1) {
		230	const uint8_t *src = src_row;
		231	uint32_t dst = (uint32_t )dst_row;
		232	uint32_t r, g0, g1, b;
		233	uint32_t value;
		234
		235	for (x = 0; x + 1 < width; x += 2) {
		236	r = (src[0] + src[4] + 1) >> 1;
		237	g0 = src[1];
		238	g1 = src[5];
		239	b = (src[2] + src[6] + 1) >> 1;
		240
		241	value = r;
		242	value \|= g0 << 8;
		243	value \|= b << 16;
		244	value \|= g1 << 24;
		245
		246	#ifdef PIPE_ARCH_BIG_ENDIAN
		247	value = util_bswap32(value);
		248	#endif
		249
		250	*dst++ = value;
		251
		252	src += 8;
		253	}
		254
		255	if (x < width) {
		256	r = src[0];
		257	g0 = src[1];
		258	g1 = 0;
		259	b = src[2];
		260
		261	value = r;
		262	value \|= g0 << 8;
		263	value \|= b << 16;
		264	value \|= g1 << 24;
		265
		266	#ifdef PIPE_ARCH_BIG_ENDIAN
		267	value = util_bswap32(value);
		268	#endif
		269
		270	*dst = value;
		271	}
		272
		273	dst_row += dst_stride/sizeof(*dst_row);
		274	src_row += src_stride/sizeof(*src_row);
		275	}
		276	}
		277
		278
		279	void
		280	util_format_r8g8_b8g8_unorm_fetch_rgba_float(float dst, const uint8_t src,
		281	unsigned i, unsigned j)
		282	{
		283	assert(i < 2);
		284	assert(j < 1);
		285
		286	dst[0] = ubyte_to_float(src[0]); /* r */
		287	dst[1] = ubyte_to_float(src[1 + 2i]); / g */
		288	dst[2] = ubyte_to_float(src[2]); /* b */
		289	dst[3] = 1.0f; /* a */
		290	}
		291
		292
		293	void
		294	util_format_g8r8_g8b8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		295	const uint8_t *src_row, unsigned src_stride,
		296	unsigned width, unsigned height)
		297	{
		298	unsigned x, y;
		299
		300	for (y = 0; y < height; y += 1) {
		301	float *dst = dst_row;
		302	const uint32_t src = (const uint32_t )src_row;
		303	uint32_t value;
		304	float r, g0, g1, b;
		305
		306	for (x = 0; x + 1 < width; x += 2) {
		307	value = *src++;
		308
		309	#ifdef PIPE_ARCH_BIG_ENDIAN
		310	value = util_bswap32(value);
		311	#endif
		312
		313	g0 = ubyte_to_float((value >> 0) & 0xff);
		314	r = ubyte_to_float((value >> 8) & 0xff);
		315	g1 = ubyte_to_float((value >> 16) & 0xff);
		316	b = ubyte_to_float((value >> 24) & 0xff);
		317
		318	dst[0] = r; /* r */
		319	dst[1] = g0; /* g */
		320	dst[2] = b; /* b */
		321	dst[3] = 1.0f; /* a */
		322	dst += 4;
		323
		324	dst[0] = r; /* r */
		325	dst[1] = g1; /* g */
		326	dst[2] = b; /* b */
		327	dst[3] = 1.0f; /* a */
		328	dst += 4;
		329	}
		330
		331	if (x < width) {
		332	value = *src;
		333
		334	#ifdef PIPE_ARCH_BIG_ENDIAN
		335	value = util_bswap32(value);
		336	#endif
		337
		338	g0 = ubyte_to_float((value >> 0) & 0xff);
		339	r = ubyte_to_float((value >> 8) & 0xff);
		340	g1 = ubyte_to_float((value >> 16) & 0xff);
		341	b = ubyte_to_float((value >> 24) & 0xff);
		342
		343	dst[0] = r; /* r */
		344	dst[1] = g0; /* g */
		345	dst[2] = b; /* b */
		346	dst[3] = 1.0f; /* a */
		347	}
		348
		349	src_row += src_stride/sizeof(*src_row);
		350	dst_row += dst_stride/sizeof(*dst_row);
		351	}
		352	}
		353
		354
		355	void
		356	util_format_g8r8_g8b8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		357	const uint8_t *src_row, unsigned src_stride,
		358	unsigned width, unsigned height)
		359	{
		360	unsigned x, y;
		361
		362	for (y = 0; y < height; y += 1) {
		363	uint8_t *dst = dst_row;
		364	const uint32_t src = (const uint32_t )src_row;
		365	uint32_t value;
		366	uint8_t r, g0, g1, b;
		367
		368	for (x = 0; x + 1 < width; x += 2) {
		369	value = *src++;
		370
		371	#ifdef PIPE_ARCH_BIG_ENDIAN
		372	value = util_bswap32(value);
		373	#endif
		374
		375	g0 = (value >> 0) & 0xff;
		376	r = (value >> 8) & 0xff;
		377	g1 = (value >> 16) & 0xff;
		378	b = (value >> 24) & 0xff;
		379
		380	dst[0] = r; /* r */
		381	dst[1] = g0; /* g */
		382	dst[2] = b; /* b */
		383	dst[3] = 0xff; /* a */
		384	dst += 4;
		385
		386	dst[0] = r; /* r */
		387	dst[1] = g1; /* g */
		388	dst[2] = b; /* b */
		389	dst[3] = 0xff; /* a */
		390	dst += 4;
		391	}
		392
		393	if (x < width) {
		394	value = *src;
		395
		396	#ifdef PIPE_ARCH_BIG_ENDIAN
		397	value = util_bswap32(value);
		398	#endif
		399
		400	g0 = (value >> 0) & 0xff;
		401	r = (value >> 8) & 0xff;
		402	g1 = (value >> 16) & 0xff;
		403	b = (value >> 24) & 0xff;
		404
		405	dst[0] = r; /* r */
		406	dst[1] = g0; /* g */
		407	dst[2] = b; /* b */
		408	dst[3] = 0xff; /* a */
		409	}
		410
		411	src_row += src_stride/sizeof(*src_row);
		412	dst_row += dst_stride/sizeof(*dst_row);
		413	}
		414	}
		415
		416
		417	void
		418	util_format_g8r8_g8b8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		419	const float *src_row, unsigned src_stride,
		420	unsigned width, unsigned height)
		421	{
		422	unsigned x, y;
		423
		424	for (y = 0; y < height; y += 1) {
		425	const float *src = src_row;
		426	uint32_t dst = (uint32_t )dst_row;
		427	float r, g0, g1, b;
		428	uint32_t value;
		429
		430	for (x = 0; x + 1 < width; x += 2) {
		431	r = 0.5f*(src[0] + src[4]);
		432	g0 = src[1];
		433	g1 = src[5];
		434	b = 0.5f*(src[2] + src[6]);
		435
		436	value = float_to_ubyte(g0);
		437	value \|= float_to_ubyte(r) << 8;
		438	value \|= float_to_ubyte(g1) << 16;
		439	value \|= float_to_ubyte(b) << 24;
		440
		441	#ifdef PIPE_ARCH_BIG_ENDIAN
		442	value = util_bswap32(value);
		443	#endif
		444
		445	*dst++ = value;
		446
		447	src += 8;
		448	}
		449
		450	if (x < width) {
		451	r = src[0];
		452	g0 = src[1];
		453	g1 = 0;
		454	b = src[2];
		455
		456	value = float_to_ubyte(g0);
		457	value \|= float_to_ubyte(r) << 8;
		458	value \|= float_to_ubyte(g1) << 16;
		459	value \|= float_to_ubyte(b) << 24;
		460
		461	#ifdef PIPE_ARCH_BIG_ENDIAN
		462	value = util_bswap32(value);
		463	#endif
		464
		465	*dst = value;
		466	}
		467
		468	dst_row += dst_stride/sizeof(*dst_row);
		469	src_row += src_stride/sizeof(*src_row);
		470	}
		471	}
		472
		473
		474	void
		475	util_format_g8r8_g8b8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		476	const uint8_t *src_row, unsigned src_stride,
		477	unsigned width, unsigned height)
		478	{
		479	unsigned x, y;
		480
		481	for (y = 0; y < height; y += 1) {
		482	const uint8_t *src = src_row;
		483	uint32_t dst = (uint32_t )dst_row;
		484	uint32_t r, g0, g1, b;
		485	uint32_t value;
		486
		487	for (x = 0; x + 1 < width; x += 2) {
		488	r = (src[0] + src[4] + 1) >> 1;
		489	g0 = src[1];
		490	g1 = src[5];
		491	b = (src[2] + src[6] + 1) >> 1;
		492
		493	value = g0;
		494	value \|= r << 8;
		495	value \|= g1 << 16;
		496	value \|= b << 24;
		497
		498	#ifdef PIPE_ARCH_BIG_ENDIAN
		499	value = util_bswap32(value);
		500	#endif
		501
		502	*dst++ = value;
		503
		504	src += 8;
		505	}
		506
		507	if (x < width) {
		508	r = src[0];
		509	g0 = src[1];
		510	g1 = 0;
		511	b = src[2];
		512
		513	value = g0;
		514	value \|= r << 8;
		515	value \|= g1 << 16;
		516	value \|= b << 24;
		517
		518	#ifdef PIPE_ARCH_BIG_ENDIAN
		519	value = util_bswap32(value);
		520	#endif
		521
		522	*dst = value;
		523	}
		524
		525	dst_row += dst_stride/sizeof(*dst_row);
		526	src_row += src_stride/sizeof(*src_row);
		527	}
		528	}
		529
		530
		531	void
		532	util_format_g8r8_g8b8_unorm_fetch_rgba_float(float dst, const uint8_t src,
		533	unsigned i, unsigned j)
		534	{
		535	assert(i < 2);
		536	assert(j < 1);
		537
		538	dst[0] = ubyte_to_float(src[1]); /* r */
		539	dst[1] = ubyte_to_float(src[0 + 2i]); / g */
		540	dst[2] = ubyte_to_float(src[3]); /* b */
		541	dst[3] = 1.0f; /* a */
		542	}
		543
		544
		545	void
		546	util_format_uyvy_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		547	const uint8_t *src_row, unsigned src_stride,
		548	unsigned width, unsigned height)
		549	{
		550	unsigned x, y;
		551
		552	for (y = 0; y < height; y += 1) {
		553	float *dst = dst_row;
		554	const uint32_t src = (const uint32_t )src_row;
		555	uint32_t value;
		556	uint8_t y0, y1, u, v;
		557
		558	for (x = 0; x + 1 < width; x += 2) {
		559	value = *src++;
		560
		561	#ifdef PIPE_ARCH_BIG_ENDIAN
		562	value = util_bswap32(value);
		563	#endif
		564
		565	u = (value >> 0) & 0xff;
		566	y0 = (value >> 8) & 0xff;
		567	v = (value >> 16) & 0xff;
		568	y1 = (value >> 24) & 0xff;
		569
		570	util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
		571	dst[3] = 1.0f; /* a */
		572	dst += 4;
		573
		574	util_format_yuv_to_rgb_float(y1, u, v, &dst[0], &dst[1], &dst[2]);
		575	dst[3] = 1.0f; /* a */
		576	dst += 4;
		577	}
		578
		579	if (x < width) {
		580	value = *src;
		581
		582	#ifdef PIPE_ARCH_BIG_ENDIAN
		583	value = util_bswap32(value);
		584	#endif
		585
		586	u = (value >> 0) & 0xff;
		587	y0 = (value >> 8) & 0xff;
		588	v = (value >> 16) & 0xff;
		589	y1 = (value >> 24) & 0xff;
		590
		591	util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
		592	dst[3] = 1.0f; /* a */
		593	}
		594
		595	src_row += src_stride/sizeof(*src_row);
		596	dst_row += dst_stride/sizeof(*dst_row);
		597	}
		598	}
		599
		600
		601	void
		602	util_format_uyvy_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		603	const uint8_t *src_row, unsigned src_stride,
		604	unsigned width, unsigned height)
		605	{
		606	unsigned x, y;
		607
		608	for (y = 0; y < height; y += 1) {
		609	uint8_t *dst = dst_row;
		610	const uint32_t src = (const uint32_t )src_row;
		611	uint32_t value;
		612	uint8_t y0, y1, u, v;
		613
		614	for (x = 0; x + 1 < width; x += 2) {
		615	value = *src++;
		616
		617	#ifdef PIPE_ARCH_BIG_ENDIAN
		618	value = util_bswap32(value);
		619	#endif
		620
		621	u = (value >> 0) & 0xff;
		622	y0 = (value >> 8) & 0xff;
		623	v = (value >> 16) & 0xff;
		624	y1 = (value >> 24) & 0xff;
		625
		626	util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
		627	dst[3] = 0xff; /* a */
		628	dst += 4;
		629
		630	util_format_yuv_to_rgb_8unorm(y1, u, v, &dst[0], &dst[1], &dst[2]);
		631	dst[3] = 0xff; /* a */
		632	dst += 4;
		633	}
		634
		635	if (x < width) {
		636	value = *src;
		637
		638	#ifdef PIPE_ARCH_BIG_ENDIAN
		639	value = util_bswap32(value);
		640	#endif
		641
		642	u = (value >> 0) & 0xff;
		643	y0 = (value >> 8) & 0xff;
		644	v = (value >> 16) & 0xff;
		645	y1 = (value >> 24) & 0xff;
		646
		647	util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
		648	dst[3] = 0xff; /* a */
		649	}
		650
		651	src_row += src_stride/sizeof(*src_row);
		652	dst_row += dst_stride/sizeof(*dst_row);
		653	}
		654	}
		655
		656
		657	void
		658	util_format_uyvy_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		659	const float *src_row, unsigned src_stride,
		660	unsigned width, unsigned height)
		661	{
		662	unsigned x, y;
		663
		664	for (y = 0; y < height; y += 1) {
		665	const float *src = src_row;
		666	uint32_t dst = (uint32_t )dst_row;
		667	uint8_t y0, y1, u, v;
		668	uint32_t value;
		669
		670	for (x = 0; x + 1 < width; x += 2) {
		671	uint8_t y0, y1, u0, u1, v0, v1, u, v;
		672
		673	util_format_rgb_float_to_yuv(src[0], src[1], src[2],
		674	&y0, &u0, &v0);
		675	util_format_rgb_float_to_yuv(src[4], src[5], src[6],
		676	&y1, &u1, &v1);
		677
		678	u = (u0 + u1 + 1) >> 1;
		679	v = (v0 + v1 + 1) >> 1;
		680
		681	value = u;
		682	value \|= y0 << 8;
		683	value \|= v << 16;
		684	value \|= y1 << 24;
		685
		686	#ifdef PIPE_ARCH_BIG_ENDIAN
		687	value = util_bswap32(value);
		688	#endif
		689
		690	*dst++ = value;
		691
		692	src += 8;
		693	}
		694
		695	if (x < width) {
		696	util_format_rgb_float_to_yuv(src[0], src[1], src[2],
		697	&y0, &u, &v);
		698	y1 = 0;
		699
		700	value = u;
		701	value \|= y0 << 8;
		702	value \|= v << 16;
		703	value \|= y1 << 24;
		704
		705	#ifdef PIPE_ARCH_BIG_ENDIAN
		706	value = util_bswap32(value);
		707	#endif
		708
		709	*dst = value;
		710	}
		711
		712	dst_row += dst_stride/sizeof(*dst_row);
		713	src_row += src_stride/sizeof(*src_row);
		714	}
		715	}
		716
		717
		718	void
		719	util_format_uyvy_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		720	const uint8_t *src_row, unsigned src_stride,
		721	unsigned width, unsigned height)
		722	{
		723	unsigned x, y;
		724
		725	for (y = 0; y < height; y += 1) {
		726	const uint8_t *src = src_row;
		727	uint32_t dst = (uint32_t )dst_row;
		728	uint8_t y0, y1, u, v;
		729	uint32_t value;
		730
		731	for (x = 0; x + 1 < width; x += 2) {
		732	uint8_t y0, y1, u0, u1, v0, v1, u, v;
		733
		734	util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
		735	&y0, &u0, &v0);
		736	util_format_rgb_8unorm_to_yuv(src[4], src[5], src[6],
		737	&y1, &u1, &v1);
		738
		739	u = (u0 + u1 + 1) >> 1;
		740	v = (v0 + v1 + 1) >> 1;
		741
		742	value = u;
		743	value \|= y0 << 8;
		744	value \|= v << 16;
		745	value \|= y1 << 24;
		746
		747	#ifdef PIPE_ARCH_BIG_ENDIAN
		748	value = util_bswap32(value);
		749	#endif
		750
		751	*dst++ = value;
		752
		753	src += 8;
		754	}
		755
		756	if (x < width) {
		757	util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
		758	&y0, &u, &v);
		759	y1 = 0;
		760
		761	value = u;
		762	value \|= y0 << 8;
		763	value \|= v << 16;
		764	value \|= y1 << 24;
		765
		766	#ifdef PIPE_ARCH_BIG_ENDIAN
		767	value = util_bswap32(value);
		768	#endif
		769
		770	*dst = value;
		771	}
		772
		773	dst_row += dst_stride/sizeof(*dst_row);
		774	src_row += src_stride/sizeof(*src_row);
		775	}
		776	}
		777
		778
		779	void
		780	util_format_uyvy_fetch_rgba_float(float dst, const uint8_t src,
		781	unsigned i, unsigned j)
		782	{
		783	uint8_t y, u, v;
		784
		785	assert(i < 2);
		786	assert(j < 1);
		787
		788	y = src[1 + i*2];
		789	u = src[0];
		790	v = src[2];
		791
		792	util_format_yuv_to_rgb_float(y, u, v, &dst[0], &dst[1], &dst[2]);
		793
		794	dst[3] = 1.0f;
		795	}
		796
		797
		798	void
		799	util_format_yuyv_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		800	const uint8_t *src_row, unsigned src_stride,
		801	unsigned width, unsigned height)
		802	{
		803	unsigned x, y;
		804
		805	for (y = 0; y < height; y += 1) {
		806	float *dst = dst_row;
		807	const uint32_t src = (const uint32_t )src_row;
		808	uint32_t value;
		809	uint8_t y0, y1, u, v;
		810
		811	for (x = 0; x + 1 < width; x += 2) {
		812	value = *src++;
		813
		814	#ifdef PIPE_ARCH_BIG_ENDIAN
		815	value = util_bswap32(value);
		816	#endif
		817
		818	y0 = (value >> 0) & 0xff;
		819	u = (value >> 8) & 0xff;
		820	y1 = (value >> 16) & 0xff;
		821	v = (value >> 24) & 0xff;
		822
		823	util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
		824	dst[3] = 1.0f; /* a */
		825	dst += 4;
		826
		827	util_format_yuv_to_rgb_float(y1, u, v, &dst[0], &dst[1], &dst[2]);
		828	dst[3] = 1.0f; /* a */
		829	dst += 4;
		830	}
		831
		832	if (x < width) {
		833	value = *src;
		834
		835	#ifdef PIPE_ARCH_BIG_ENDIAN
		836	value = util_bswap32(value);
		837	#endif
		838
		839	y0 = (value >> 0) & 0xff;
		840	u = (value >> 8) & 0xff;
		841	y1 = (value >> 16) & 0xff;
		842	v = (value >> 24) & 0xff;
		843
		844	util_format_yuv_to_rgb_float(y0, u, v, &dst[0], &dst[1], &dst[2]);
		845	dst[3] = 1.0f; /* a */
		846	}
		847
		848	src_row += src_stride/sizeof(*src_row);
		849	dst_row += dst_stride/sizeof(*dst_row);
		850	}
		851	}
		852
		853
		854	void
		855	util_format_yuyv_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		856	const uint8_t *src_row, unsigned src_stride,
		857	unsigned width, unsigned height)
		858	{
		859	unsigned x, y;
		860
		861	for (y = 0; y < height; y += 1) {
		862	uint8_t *dst = dst_row;
		863	const uint32_t src = (const uint32_t )src_row;
		864	uint32_t value;
		865	uint8_t y0, y1, u, v;
		866
		867	for (x = 0; x + 1 < width; x += 2) {
		868	value = *src++;
		869
		870	#ifdef PIPE_ARCH_BIG_ENDIAN
		871	value = util_bswap32(value);
		872	#endif
		873
		874	y0 = (value >> 0) & 0xff;
		875	u = (value >> 8) & 0xff;
		876	y1 = (value >> 16) & 0xff;
		877	v = (value >> 24) & 0xff;
		878
		879	util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
		880	dst[3] = 0xff; /* a */
		881	dst += 4;
		882
		883	util_format_yuv_to_rgb_8unorm(y1, u, v, &dst[0], &dst[1], &dst[2]);
		884	dst[3] = 0xff; /* a */
		885	dst += 4;
		886	}
		887
		888	if (x < width) {
		889	value = *src;
		890
		891	#ifdef PIPE_ARCH_BIG_ENDIAN
		892	value = util_bswap32(value);
		893	#endif
		894
		895	y0 = (value >> 0) & 0xff;
		896	u = (value >> 8) & 0xff;
		897	y1 = (value >> 16) & 0xff;
		898	v = (value >> 24) & 0xff;
		899
		900	util_format_yuv_to_rgb_8unorm(y0, u, v, &dst[0], &dst[1], &dst[2]);
		901	dst[3] = 0xff; /* a */
		902	}
		903
		904	src_row += src_stride/sizeof(*src_row);
		905	dst_row += dst_stride/sizeof(*dst_row);
		906	}
		907	}
		908
		909
		910	void
		911	util_format_yuyv_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		912	const float *src_row, unsigned src_stride,
		913	unsigned width, unsigned height)
		914	{
		915	unsigned x, y;
		916
		917	for (y = 0; y < height; y += 1) {
		918	const float *src = src_row;
		919	uint32_t dst = (uint32_t )dst_row;
		920	uint8_t y0, y1, u, v;
		921	uint32_t value;
		922
		923	for (x = 0; x + 1 < width; x += 2) {
		924	uint8_t y0, y1, u0, u1, v0, v1, u, v;
		925
		926	util_format_rgb_float_to_yuv(src[0], src[1], src[2],
		927	&y0, &u0, &v0);
		928	util_format_rgb_float_to_yuv(src[4], src[5], src[6],
		929	&y1, &u1, &v1);
		930
		931	u = (u0 + u1 + 1) >> 1;
		932	v = (v0 + v1 + 1) >> 1;
		933
		934	value = y0;
		935	value \|= u << 8;
		936	value \|= y1 << 16;
		937	value \|= v << 24;
		938
		939	#ifdef PIPE_ARCH_BIG_ENDIAN
		940	value = util_bswap32(value);
		941	#endif
		942
		943	*dst++ = value;
		944
		945	src += 8;
		946	}
		947
		948	if (x < width) {
		949	util_format_rgb_float_to_yuv(src[0], src[1], src[2],
		950	&y0, &u, &v);
		951	y1 = 0;
		952
		953	value = y0;
		954	value \|= u << 8;
		955	value \|= y1 << 16;
		956	value \|= v << 24;
		957
		958	#ifdef PIPE_ARCH_BIG_ENDIAN
		959	value = util_bswap32(value);
		960	#endif
		961
		962	*dst = value;
		963	}
		964
		965	dst_row += dst_stride/sizeof(*dst_row);
		966	src_row += src_stride/sizeof(*src_row);
		967	}
		968	}
		969
		970
		971	void
		972	util_format_yuyv_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		973	const uint8_t *src_row, unsigned src_stride,
		974	unsigned width, unsigned height)
		975	{
		976	unsigned x, y;
		977
		978	for (y = 0; y < height; y += 1) {
		979	const uint8_t *src = src_row;
		980	uint32_t dst = (uint32_t )dst_row;
		981	uint8_t y0, y1, u, v;
		982	uint32_t value;
		983
		984	for (x = 0; x + 1 < width; x += 2) {
		985	uint8_t y0, y1, u0, u1, v0, v1, u, v;
		986
		987	util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
		988	&y0, &u0, &v0);
		989	util_format_rgb_8unorm_to_yuv(src[4], src[5], src[6],
		990	&y1, &u1, &v1);
		991
		992	u = (u0 + u1 + 1) >> 1;
		993	v = (v0 + v1 + 1) >> 1;
		994
		995	value = y0;
		996	value \|= u << 8;
		997	value \|= y1 << 16;
		998	value \|= v << 24;
		999
		1000	#ifdef PIPE_ARCH_BIG_ENDIAN
		1001	value = util_bswap32(value);
		1002	#endif
		1003
		1004	*dst++ = value;
		1005
		1006	src += 8;
		1007	}
		1008
		1009	if (x < width) {
		1010	util_format_rgb_8unorm_to_yuv(src[0], src[1], src[2],
		1011	&y0, &u, &v);
		1012	y1 = 0;
		1013
		1014	value = y0;
		1015	value \|= u << 8;
		1016	value \|= y1 << 16;
		1017	value \|= v << 24;
		1018
		1019	#ifdef PIPE_ARCH_BIG_ENDIAN
		1020	value = util_bswap32(value);
		1021	#endif
		1022
		1023	*dst = value;
		1024	}
		1025
		1026	dst_row += dst_stride/sizeof(*dst_row);
		1027	src_row += src_stride/sizeof(*src_row);
		1028	}
		1029	}
		1030
		1031
		1032	void
		1033	util_format_yuyv_fetch_rgba_float(float dst, const uint8_t src,
		1034	unsigned i, unsigned j)
		1035	{
		1036	uint8_t y, u, v;
		1037
		1038	assert(i < 2);
		1039	assert(j < 1);
		1040
		1041	y = src[0 + i*2];
		1042	u = src[1];
		1043	v = src[3];
		1044
		1045	util_format_yuv_to_rgb_float(y, u, v, &dst[0], &dst[1], &dst[2]);
		1046
		1047	dst[3] = 1.0f;
		1048	}
		1049
		1050	/* XXX: Stubbed for now */
		1051	void
		1052	util_format_yv12_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1053	const uint8_t *src_row, unsigned src_stride,
		1054	unsigned width, unsigned height) {}
		1055	void
		1056	util_format_yv12_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1057	const uint8_t *src_row, unsigned src_stride,
		1058	unsigned width, unsigned height) {}
		1059	void
		1060	util_format_yv12_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		1061	const uint8_t *src_row, unsigned src_stride,
		1062	unsigned width, unsigned height) {}
		1063	void
		1064	util_format_yv12_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		1065	const float *src_row, unsigned src_stride,
		1066	unsigned width, unsigned height) {}
		1067	void
		1068	util_format_yv12_fetch_rgba_float(float dst, const uint8_t src,
		1069	unsigned i, unsigned j) {}
		1070	void
		1071	util_format_yv16_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1072	const uint8_t *src_row, unsigned src_stride,
		1073	unsigned width, unsigned height) {}
		1074	void
		1075	util_format_yv16_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1076	const uint8_t *src_row, unsigned src_stride,
		1077	unsigned width, unsigned height) {}
		1078	void
		1079	util_format_yv16_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		1080	const uint8_t *src_row, unsigned src_stride,
		1081	unsigned width, unsigned height) {}
		1082	void
		1083	util_format_yv16_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		1084	const float *src_row, unsigned src_stride,
		1085	unsigned width, unsigned height) {}
		1086	void
		1087	util_format_yv16_fetch_rgba_float(float dst, const uint8_t src,
		1088	unsigned i, unsigned j) {}
		1089	void
		1090	util_format_iyuv_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1091	const uint8_t *src_row, unsigned src_stride,
		1092	unsigned width, unsigned height) {}
		1093	void
		1094	util_format_iyuv_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1095	const uint8_t *src_row, unsigned src_stride,
		1096	unsigned width, unsigned height) {}
		1097	void
		1098	util_format_iyuv_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		1099	const uint8_t *src_row, unsigned src_stride,
		1100	unsigned width, unsigned height) {}
		1101	void
		1102	util_format_iyuv_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		1103	const float *src_row, unsigned src_stride,
		1104	unsigned width, unsigned height) {}
		1105	void
		1106	util_format_iyuv_fetch_rgba_float(float dst, const uint8_t src,
		1107	unsigned i, unsigned j) {}
		1108	void
		1109	util_format_nv12_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1110	const uint8_t *src_row, unsigned src_stride,
		1111	unsigned width, unsigned height) {}
		1112	void
		1113	util_format_nv12_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1114	const uint8_t *src_row, unsigned src_stride,
		1115	unsigned width, unsigned height) {}
		1116	void
		1117	util_format_nv12_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		1118	const uint8_t *src_row, unsigned src_stride,
		1119	unsigned width, unsigned height) {}
		1120	void
		1121	util_format_nv12_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		1122	const float *src_row, unsigned src_stride,
		1123	unsigned width, unsigned height) {}
		1124	void
		1125	util_format_nv12_fetch_rgba_float(float dst, const uint8_t src,
		1126	unsigned i, unsigned j) {}
		1127	void
		1128	util_format_nv21_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1129	const uint8_t *src_row, unsigned src_stride,
		1130	unsigned width, unsigned height) {}
		1131	void
		1132	util_format_nv21_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1133	const uint8_t *src_row, unsigned src_stride,
		1134	unsigned width, unsigned height) {}
		1135	void
		1136	util_format_nv21_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		1137	const uint8_t *src_row, unsigned src_stride,
		1138	unsigned width, unsigned height) {}
		1139	void
		1140	util_format_nv21_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		1141	const float *src_row, unsigned src_stride,
		1142	unsigned width, unsigned height) {}
		1143	void
		1144	util_format_nv21_fetch_rgba_float(float dst, const uint8_t src,
		1145	unsigned i, unsigned j) {}
		1146
		1147	void
		1148	util_format_r8g8_r8b8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		1149	const uint8_t *src_row, unsigned src_stride,
		1150	unsigned width, unsigned height) {}
		1151
		1152	void
		1153	util_format_r8g8_r8b8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1154	const uint8_t *src_row, unsigned src_stride,
		1155	unsigned width, unsigned height) {}
		1156
		1157	void
		1158	util_format_r8g8_r8b8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		1159	const float *src_row, unsigned src_stride,
		1160	unsigned width, unsigned height) {}
		1161
		1162	void
		1163	util_format_r8g8_r8b8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1164	const uint8_t *src_row, unsigned src_stride,
		1165	unsigned width, unsigned height) {}
		1166
		1167	void
		1168	util_format_r8g8_r8b8_unorm_fetch_rgba_float(float dst, const uint8_t src,
		1169	unsigned i, unsigned j) {}
		1170
		1171	void
		1172	util_format_g8r8_b8r8_unorm_unpack_rgba_float(float *dst_row, unsigned dst_stride,
		1173	const uint8_t *src_row, unsigned src_stride,
		1174	unsigned width, unsigned height) {}
		1175
		1176	void
		1177	util_format_g8r8_b8r8_unorm_unpack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1178	const uint8_t *src_row, unsigned src_stride,
		1179	unsigned width, unsigned height) {}
		1180
		1181	void
		1182	util_format_g8r8_b8r8_unorm_pack_rgba_float(uint8_t *dst_row, unsigned dst_stride,
		1183	const float *src_row, unsigned src_stride,
		1184	unsigned width, unsigned height) {}
		1185
		1186	void
		1187	util_format_g8r8_b8r8_unorm_pack_rgba_8unorm(uint8_t *dst_row, unsigned dst_stride,
		1188	const uint8_t *src_row, unsigned src_stride,
		1189	unsigned width, unsigned height) {}
		1190
		1191	void
		1192	util_format_g8r8_b8r8_unorm_fetch_rgba_float(float dst, const uint8_t src,
		1193	unsigned i, unsigned j) {}

Subversion Repositories Kolibri OS

(root)/drivers/video/Gallium/auxiliary/util/u_format_yuv.c – Rev 3770