[pcsx_rearmed.git] / libpcsxcore / mdec.c

/***************************************************************************
 *   Copyright (C) 2010 Gabriele Gorla                                     *
 *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team              *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
 ***************************************************************************/

#include "mdec.h"

#define DSIZE			8
#define DSIZE2			(DSIZE * DSIZE)

#define SCALE(x, n)		((x) >> (n))
#define SCALER(x, n)	(((x) + ((1 << (n)) >> 1)) >> (n))

#define AAN_CONST_BITS			12
#define AAN_PRESCALE_BITS		16

#define AAN_CONST_SIZE			24
#define AAN_CONST_SCALE			(AAN_CONST_SIZE - AAN_CONST_BITS)

#define AAN_PRESCALE_SIZE		20
#define AAN_PRESCALE_SCALE		(AAN_PRESCALE_SIZE-AAN_PRESCALE_BITS)
#define AAN_EXTRA				12

#define FIX_1_082392200		SCALER(18159528, AAN_CONST_SCALE) // B6
#define FIX_1_414213562		SCALER(23726566, AAN_CONST_SCALE) // A4
#define FIX_1_847759065		SCALER(31000253, AAN_CONST_SCALE) // A2
#define FIX_2_613125930		SCALER(43840978, AAN_CONST_SCALE) // B2

#define MULS(var, const)	(SCALE((var) * (const), AAN_CONST_BITS))

#define	RLE_RUN(a)	((a) >> 10)
#define	RLE_VAL(a)	(((int)(a) << (sizeof(int) * 8 - 10)) >> (sizeof(int) * 8 - 10))

#if 0
static void printmatrixu8(u8 *m) {
	int i;
	for(i = 0; i < DSIZE2; i++) {
		printf("%3d ",m[i]);
		if((i+1) % 8 == 0) printf("\n");
	}
}
#endif

static inline void fillcol(int *blk, int val) {
	blk[0 * DSIZE] = blk[1 * DSIZE] = blk[2 * DSIZE] = blk[3 * DSIZE]
		= blk[4 * DSIZE] = blk[5 * DSIZE] = blk[6 * DSIZE] = blk[7 * DSIZE] = val;
}

static inline void fillrow(int *blk, int val) {
	blk[0] = blk[1] = blk[2] = blk[3]
		= blk[4] = blk[5] = blk[6] = blk[7] = val;
}

void idct(int *block,int used_col) {
	int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
	int z5, z10, z11, z12, z13;
	int *ptr;
	int i;

	// the block has only the DC coefficient
	if (used_col == -1) { 
		int v = block[0];
		for (i = 0; i < DSIZE2; i++) block[i] = v;
		return;
	}

	// last_col keeps track of the highest column with non zero coefficients
	ptr = block;
	for (i = 0; i < DSIZE; i++, ptr++) {
		if ((used_col & (1 << i)) == 0) {
			// the column is empty or has only the DC coefficient
			if (ptr[DSIZE * 0]) {
				fillcol(ptr, ptr[0]);
				used_col |= (1 << i);
			}
			continue;
		}

		// further optimization could be made by keeping track of 
		// last_row in rl2blk
		z10 = ptr[DSIZE * 0] + ptr[DSIZE * 4]; // s04
		z11 = ptr[DSIZE * 0] - ptr[DSIZE * 4]; // d04
		z13 = ptr[DSIZE * 2] + ptr[DSIZE * 6]; // s26
		z12 = MULS(ptr[DSIZE * 2] - ptr[DSIZE * 6], FIX_1_414213562) - z13; 
		//^^^^  d26=d26*2*A4-s26

		tmp0 = z10 + z13; // os07 = s04 + s26
		tmp3 = z10 - z13; // os34 = s04 - s26
		tmp1 = z11 + z12; // os16 = d04 + d26
		tmp2 = z11 - z12; // os25 = d04 - d26

		z13 = ptr[DSIZE * 3] + ptr[DSIZE * 5]; //s53
		z10 = ptr[DSIZE * 3] - ptr[DSIZE * 5]; //-d53 
		z11 = ptr[DSIZE * 1] + ptr[DSIZE * 7]; //s17
		z12 = ptr[DSIZE * 1] - ptr[DSIZE * 7]; //d17

		tmp7 = z11 + z13; // od07 = s17 + s53

		z5 = (z12 - z10) * (FIX_1_847759065); 
		tmp6 = SCALE(z10*(FIX_2_613125930) + z5, AAN_CONST_BITS) - tmp7; 
		tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
		tmp4 = SCALE(z12*(FIX_1_082392200) - z5, AAN_CONST_BITS) + tmp5; 

		// path #1
		//z5 = (z12 - z10)* FIX_1_847759065; 
		// tmp0 = (d17 + d53) * 2*A2

		//tmp6 = DESCALE(z10*FIX_2_613125930 + z5, CONST_BITS) - tmp7; 
		// od16 = (d53*-2*B2 + tmp0) - od07

		//tmp4 = DESCALE(z12*FIX_1_082392200 - z5, CONST_BITS) + tmp5; 
		// od34 = (d17*2*B6 - tmp0) + od25

		// path #2

		// od34 = d17*2*(B6-A2) - d53*2*A2
		// od16 = d53*2*(A2-B2) + d17*2*A2

		// end

		//    tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
		// od25 = (s17 - s53)*2*A4 - od16

		ptr[DSIZE * 0] = (tmp0 + tmp7); // os07 + od07
		ptr[DSIZE * 7] = (tmp0 - tmp7); // os07 - od07
		ptr[DSIZE * 1] = (tmp1 + tmp6); // os16 + od16
		ptr[DSIZE * 6] = (tmp1 - tmp6); // os16 - od16
		ptr[DSIZE * 2] = (tmp2 + tmp5); // os25 + od25
		ptr[DSIZE * 5] = (tmp2 - tmp5); // os25 - od25
		ptr[DSIZE * 4] = (tmp3 + tmp4); // os34 + od34
		ptr[DSIZE * 3] = (tmp3 - tmp4); // os34 - od34
	}

	ptr = block;
	if (used_col == 1) {
		for (i = 0; i < DSIZE; i++)
			fillrow(block + DSIZE * i, block[DSIZE * i]);    
	} else {
		for (i = 0; i < DSIZE; i++, ptr += DSIZE) {
			z10 = ptr[0] + ptr[4];
			z11 = ptr[0] - ptr[4];
			z13 = ptr[2] + ptr[6];
			z12 = MULS(ptr[2] - ptr[6], FIX_1_414213562) - z13;

			tmp0 = z10 + z13;
			tmp3 = z10 - z13;
			tmp1 = z11 + z12;
			tmp2 = z11 - z12;
			
			z13 = ptr[3] + ptr[5];
			z10 = ptr[3] - ptr[5];
			z11 = ptr[1] + ptr[7];
			z12 = ptr[1] - ptr[7];

			tmp7 = z11 + z13;
			z5 = (z12 - z10) * FIX_1_847759065; 
			tmp6 = SCALE(z10 * FIX_2_613125930 + z5, AAN_CONST_BITS) - tmp7;
			tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
			tmp4 = SCALE(z12 * FIX_1_082392200 - z5, AAN_CONST_BITS) + tmp5;

			ptr[0] = tmp0 + tmp7;

			ptr[7] = tmp0 - tmp7;
			ptr[1] = tmp1 + tmp6;
			ptr[6] = tmp1 - tmp6;
			ptr[2] = tmp2 + tmp5;
			ptr[5] = tmp2 - tmp5;
			ptr[4] = tmp3 + tmp4;
			ptr[3] = tmp3 - tmp4;
		}
	}
}

// mdec0: command register
#define MDEC0_STP			0x02000000
#define MDEC0_RGB24			0x08000000
#define MDEC0_SIZE_MASK		0xFFFF

// mdec1: status register
#define MDEC1_BUSY			0x20000000
#define MDEC1_DREQ			0x18000000
#define MDEC1_FIFO			0xc0000000
#define MDEC1_RGB24			0x02000000
#define MDEC1_STP			0x00800000
#define MDEC1_RESET			0x80000000

struct {
    u32 reg0;
    u32 reg1;
    unsigned short *rl;
    int rlsize;
} mdec;

static int iq_y[DSIZE2], iq_uv[DSIZE2];

static int zscan[DSIZE2] = {
	0 , 1 , 8 , 16, 9 , 2 , 3 , 10,
	17, 24, 32, 25, 18, 11, 4 , 5 ,
	12, 19, 26, 33, 40, 48, 41, 34,
	27, 20, 13, 6 , 7 , 14, 21, 28,
	35, 42, 49, 56, 57, 50, 43, 36,
	29, 22, 15, 23, 30, 37, 44, 51,
	58, 59, 52, 45, 38, 31, 39, 46,
	53, 60, 61, 54, 47, 55, 62, 63
};

static int aanscales[DSIZE2] = {
	1048576, 1454417, 1370031, 1232995, 1048576,  823861, 567485, 289301,
	1454417, 2017334, 1900287, 1710213, 1454417, 1142728, 787125, 401273,
	1370031, 1900287, 1790031, 1610986, 1370031, 1076426, 741455, 377991,
	1232995, 1710213, 1610986, 1449849, 1232995,  968758, 667292, 340183,
	1048576, 1454417, 1370031, 1232995, 1048576,  823861, 567485, 289301,
	823861,  1142728, 1076426, 968758,  823861,  647303, 445870, 227303,
	567485,  787125,  741455,  667292,  567485,  445870, 307121, 156569,
	289301,  401273,  377991,  340183,  289301,  227303, 156569,  79818
};

static void iqtab_init(int *iqtab, unsigned char *iq_y) {
	int i;

	for (i = 0; i < DSIZE2; i++) {
		iqtab[i] = (iq_y[i] * SCALER(aanscales[zscan[i]], AAN_PRESCALE_SCALE));
	}
}

#define	MDEC_END_OF_DATA	0xfe00

unsigned short *rl2blk(int *blk, unsigned short *mdec_rl) {
	int i, k, q_scale, rl, used_col;
 	int *iqtab;

	memset(blk, 0, 6 * DSIZE2 * sizeof(int));
	iqtab = iq_uv;
	for (i = 0; i < 6; i++) {
		// decode blocks (Cr,Cb,Y1,Y2,Y3,Y4)
		if (i == 2) iqtab = iq_y;

		rl = SWAP16(*mdec_rl); mdec_rl++;
		q_scale = RLE_RUN(rl);
		blk[0] = SCALER(iqtab[0] * RLE_VAL(rl), AAN_EXTRA - 3);
		for (k = 0, used_col = 0;;) {
			rl = SWAP16(*mdec_rl); mdec_rl++;
			if (rl == MDEC_END_OF_DATA) break;
			k += RLE_RUN(rl) + 1;	// skip zero-coefficients

			if (k > 63) {
				// printf("run lenght exceeded 64 enties\n");
				break;
			}

			// zigzag transformation
			blk[zscan[k]] = SCALER(RLE_VAL(rl) * iqtab[k] * q_scale, AAN_EXTRA);
			// keep track of used columns to speed up the idtc
			used_col |= (zscan[k] > 7) ? 1 << (zscan[k] & 7) : 0;
		}

		if (k == 0) used_col = -1;
		// used_col is -1 for blocks with only the DC coefficient
		// any other value is a bitmask of the columns that have 
		// at least one non zero cofficient in the rows 1-7
		// single coefficients in row 0 are treted specially 
		// in the idtc function
		idct(blk, used_col);
		blk += DSIZE2;
	}
	return mdec_rl;
}

// full scale (JPEG)
// Y/Cb/Cr[0...255] -> R/G/B[0...255]
// R = 1.000 * (Y) + 1.400 * (Cr - 128)
// G = 1.000 * (Y) - 0.343 * (Cb - 128) - 0.711 (Cr - 128)
// B = 1.000 * (Y) + 1.765 * (Cb - 128)
#define	MULR(a)			((1434 * (a))) 
#define	MULB(a)			((1807 * (a))) 
#define	MULG2(a, b)		((-351 * (a) - 728 * (b)))
#define MULY(a)			((a) << 10)

#define	MAKERGB15(r, g, b, a)	(SWAP16(a | ((b) << 10) | ((g) << 5) | (r)))
#define	SCALE8(c)				SCALER(c, 20) 
#define SCALE5(c)				SCALER(c, 23)

#define CLAMP5(c)	( ((c) < -16) ? 0 : (((c) > (31 - 16)) ? 31 : ((c) + 16)) )
#define CLAMP8(c)	( ((c) < -128) ? 0 : (((c) > (255 - 128)) ? 255 : ((c) + 128)) )

#define CLAMP_SCALE8(a)   (CLAMP8(SCALE8(a)))
#define CLAMP_SCALE5(a)   (CLAMP5(SCALE5(a)))

static inline void putlinebw15(unsigned short *image, int *Yblk) {
	int i;
	int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;

	for (i = 0; i < 8; i++, Yblk++) {
		int Y = *Yblk;
		// missing rounding
		image[i] = SWAP16((CLAMP5(Y >> 3) * 0x421) | A);
	}
}

static void putquadrgb15(unsigned short *image, int *Yblk, int Cr, int Cb) {
	int Y, R, G, B;
	int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
	R = MULR(Cr);
	G = MULG2(Cb, Cr);
	B = MULB(Cb);

	// added transparency
	Y = MULY(Yblk[0]);
	image[0] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
	Y = MULY(Yblk[1]);
	image[1] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
	Y = MULY(Yblk[8]);
	image[16] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
	Y = MULY(Yblk[9]);
	image[17] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
}

static void yuv2rgb15(int *blk, unsigned short *image) {
	int x, y;
	int *Yblk = blk + DSIZE2 * 2;
	int *Crblk = blk;
	int *Cbblk = blk + DSIZE2;

	if (!Config.Mdec) {
		for (y = 0; y < 16; y += 2, Crblk += 4, Cbblk += 4, Yblk += 8, image += 24) {
			if (y == 8) Yblk += DSIZE2;
			for (x = 0; x < 4; x++, image += 2, Crblk++, Cbblk++, Yblk += 2) {
				putquadrgb15(image, Yblk, *Crblk, *Cbblk);
				putquadrgb15(image + 8, Yblk + DSIZE2, *(Crblk + 4), *(Cbblk + 4));
			}
		} 
	} else {
		for (y = 0; y < 16; y++, Yblk += 8, image += 16) {
			if (y == 8) Yblk += DSIZE2;
			putlinebw15(image, Yblk);
			putlinebw15(image + 8, Yblk + DSIZE2);
		}
	}
}

static inline void putlinebw24(unsigned char *image, int *Yblk) {
	int i;
	unsigned char Y;
	for (i = 0; i < 8 * 3; i += 3, Yblk++) {
		Y = CLAMP8(*Yblk);
		image[i + 0] = Y;
		image[i + 1] = Y;
		image[i + 2] = Y;
	}
}

static void putquadrgb24(unsigned char *image, int *Yblk, int Cr, int Cb) {
	int Y, R, G, B;

	R = MULR(Cr);
	G = MULG2(Cb,Cr);
	B = MULB(Cb);

	Y = MULY(Yblk[0]);
	image[0 * 3 + 0] = CLAMP_SCALE8(Y + R);
	image[0 * 3 + 1] = CLAMP_SCALE8(Y + G);
	image[0 * 3 + 2] = CLAMP_SCALE8(Y + B);
	Y = MULY(Yblk[1]);
	image[1 * 3 + 0] = CLAMP_SCALE8(Y + R);
	image[1 * 3 + 1] = CLAMP_SCALE8(Y + G);
	image[1 * 3 + 2] = CLAMP_SCALE8(Y + B);
	Y = MULY(Yblk[8]);
	image[16 * 3 + 0] = CLAMP_SCALE8(Y + R);
	image[16 * 3 + 1] = CLAMP_SCALE8(Y + G);
	image[16 * 3 + 2] = CLAMP_SCALE8(Y + B);
	Y = MULY(Yblk[9]);
	image[17 * 3 + 0] = CLAMP_SCALE8(Y + R);
	image[17 * 3 + 1] = CLAMP_SCALE8(Y + G);
	image[17 * 3 + 2] = CLAMP_SCALE8(Y + B);
}

static void yuv2rgb24(int *blk, unsigned char *image) {
	int x, y;
	int *Yblk = blk + DSIZE2 * 2;
	int *Crblk = blk;
	int *Cbblk = blk + DSIZE2;

	if (!Config.Mdec) {
		for (y = 0; y < 16; y += 2, Crblk += 4, Cbblk += 4, Yblk += 8, image += 24 * 3) {
			if (y == 8) Yblk += DSIZE2;
			for (x = 0; x < 4; x++, image += 6, Crblk++, Cbblk++, Yblk += 2) {
				putquadrgb24(image, Yblk, *Crblk, *Cbblk);
				putquadrgb24(image + 8 * 3, Yblk + DSIZE2, *(Crblk + 4), *(Cbblk + 4));
			}
		}
	} else {
		for (y = 0; y < 16; y++, Yblk += 8, image += 16 * 3) {
			if (y == 8) Yblk += DSIZE2;
			putlinebw24(image, Yblk);
			putlinebw24(image + 8 * 3, Yblk + DSIZE2);
		}
	}
}

void mdecInit(void) {
	mdec.rl = (u16 *)&psxM[0x100000];
	mdec.reg0 = 0;
	mdec.reg1 = 0;
}

// command register
void mdecWrite0(u32 data) {
#ifdef CDR_LOG
	CDR_LOG("mdec0 write %08x\n", data);
#endif
	mdec.reg0 = data;
}

u32 mdecRead0(void) {
#ifdef CDR_LOG
	CDR_LOG("mdec0 read %08x\n", mdec.reg0);
#endif
	// mame is returning 0
	return mdec.reg0;
}

// status register
void mdecWrite1(u32 data) {
#ifdef CDR_LOG
	CDR_LOG("mdec1 write %08x\n", data);
#endif
	if (data & MDEC1_RESET) { // mdec reset
		mdec.reg0 = 0;
		mdec.reg1 = 0;
	}
}

u32 mdecRead1(void) {
	u32 v = mdec.reg1;
	v |= (mdec.reg0 & MDEC0_STP) ? MDEC1_STP : 0;
	v |= (mdec.reg0 & MDEC0_RGB24) ? MDEC1_RGB24 : 0;
#ifdef CDR_LOG
	CDR_LOG("mdec1 read %08x\n", v);
#endif
	return v;
}

void psxDma0(u32 adr, u32 bcr, u32 chcr) {
	int cmd = mdec.reg0;
	int size;
	
#ifdef CDR_LOG
	CDR_LOG("DMA0 %08x %08x %08x\n", adr, bcr, chcr);
#endif

	if (chcr != 0x01000201) {
		// printf("chcr != 0x01000201\n");
		return;
	}

	size = (bcr >> 16) * (bcr & 0xffff);

	switch (cmd >> 28) {
		case 0x3: // decode
			mdec.rl = (u16 *)PSXM(adr);
			mdec.rlsize = mdec.reg0 & MDEC0_SIZE_MASK;
			break;

		case 0x4: // quantization table upload
			{
				u8 *p = (u8 *)PSXM(adr);
				// printf("uploading new quantization table\n");
				// printmatrixu8(p);
				// printmatrixu8(p + 64);
				iqtab_init(iq_y, p);
				iqtab_init(iq_uv, p + 64);
			}
			break;

		case 0x6: // cosine table
			// printf("mdec cosine table\n");
			break;

		default:
			// printf("mdec unknown command\n");
			break;
	}

	HW_DMA0_CHCR &= SWAP32(~0x01000000);
	DMA_INTERRUPT(0);
}

void psxDma1(u32 adr, u32 bcr, u32 chcr) {
	int blk[DSIZE2 * 6];
	unsigned short *image;
	int size;

#ifdef CDR_LOG
	CDR_LOG("DMA1 %08x %08x %08x (cmd = %08x)\n", adr, bcr, chcr, mdec.reg0);
#endif

	if (chcr != 0x01000200) return;

	size = (bcr >> 16) * (bcr & 0xffff);

	image = (u16 *)PSXM(adr);

	if (mdec.reg0 & MDEC0_RGB24) { // 15-b decoding
		// MDECOUTDMA_INT(((size * (1000000 / 9000)) / 4) /** 4*/);
		MDECOUTDMA_INT(size / 4);
		size = size / ((16 * 16) / 2);
		for (; size > 0; size--, image += (16 * 16)) {
			mdec.rl = rl2blk(blk, mdec.rl);
			yuv2rgb15(blk, image);
		}
	} else { // 24-b decoding
		// MDECOUTDMA_INT(((size * (1000000 / 9000)) / 4) /** 4*/);
		MDECOUTDMA_INT(size / 4);
		size = size / ((24 * 16) / 2);
		for (; size > 0; size--, image += (24 * 16)) {
			mdec.rl = rl2blk(blk, mdec.rl);
			yuv2rgb24(blk, (u8 *)image);
		}
	}

	mdec.reg1 |= MDEC1_BUSY;
}

void mdec1Interrupt() {
#ifdef CDR_LOG
	CDR_LOG("mdec1Interrupt\n");
#endif
	if (HW_DMA1_CHCR & SWAP32(0x01000000)) {
		// Set a fixed value totaly arbitrarie another sound value is
		// PSXCLK / 60 or PSXCLK / 50 since the bug happened at end of frame.
		// PSXCLK / 1000 seems good for FF9. (for FF9 need < ~28000)
		// CAUTION: commented interrupt-handling may lead to problems, keep an eye ;-)
		MDECOUTDMA_INT(PSXCLK / 1000 * BIAS);
//		psxRegs.interrupt |= 0x02000000;
//		psxRegs.intCycle[5 + 24 + 1] *= 8;
//		psxRegs.intCycle[5 + 24] = psxRegs.cycle;
		HW_DMA1_CHCR &= SWAP32(~0x01000000);
		DMA_INTERRUPT(1);
	} else {
		mdec.reg1 &= ~MDEC1_BUSY;
	}
}

int mdecFreeze(gzFile f, int Mode) {
	gzfreeze(&mdec, sizeof(mdec));
	gzfreeze(iq_y, sizeof(iq_y));
	gzfreeze(iq_uv, sizeof(iq_uv));

	return 0;
}
Commit	Line	Data
ef79bbde P	1	/***************************************************************************
	2	* Copyright (C) 2010 Gabriele Gorla *
	3	* Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team *
	4	* *
	5	* This program is free software; you can redistribute it and/or modify *
	6	* it under the terms of the GNU General Public License as published by *
	7	* the Free Software Foundation; either version 2 of the License, or *
	8	* (at your option) any later version. *
	9	* *
	10	* This program is distributed in the hope that it will be useful, *
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	13	* GNU General Public License for more details. *
	14	* *
	15	* You should have received a copy of the GNU General Public License *
	16	* along with this program; if not, write to the *
	17	* Free Software Foundation, Inc., *
	18	* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
	19	***************************************************************************/
	20
	21	#include "mdec.h"
	22
	23	#define DSIZE 8
	24	#define DSIZE2 (DSIZE * DSIZE)
	25
	26	#define SCALE(x, n) ((x) >> (n))
	27	#define SCALER(x, n) (((x) + ((1 << (n)) >> 1)) >> (n))
	28
	29	#define AAN_CONST_BITS 12
	30	#define AAN_PRESCALE_BITS 16
	31
	32	#define AAN_CONST_SIZE 24
	33	#define AAN_CONST_SCALE (AAN_CONST_SIZE - AAN_CONST_BITS)
	34
	35	#define AAN_PRESCALE_SIZE 20
	36	#define AAN_PRESCALE_SCALE (AAN_PRESCALE_SIZE-AAN_PRESCALE_BITS)
	37	#define AAN_EXTRA 12
	38
	39	#define FIX_1_082392200 SCALER(18159528, AAN_CONST_SCALE) // B6
	40	#define FIX_1_414213562 SCALER(23726566, AAN_CONST_SCALE) // A4
	41	#define FIX_1_847759065 SCALER(31000253, AAN_CONST_SCALE) // A2
	42	#define FIX_2_613125930 SCALER(43840978, AAN_CONST_SCALE) // B2
	43
	44	#define MULS(var, const) (SCALE((var) * (const), AAN_CONST_BITS))
	45
	46	#define RLE_RUN(a) ((a) >> 10)
	47	#define RLE_VAL(a) (((int)(a) << (sizeof(int) * 8 - 10)) >> (sizeof(int) * 8 - 10))
	48
	49	#if 0
	50	static void printmatrixu8(u8 *m) {
	51	int i;
	52	for(i = 0; i < DSIZE2; i++) {
	53	printf("%3d ",m[i]);
	54	if((i+1) % 8 == 0) printf("\n");
	55	}
	56	}
	57	#endif
	58
	59	static inline void fillcol(int *blk, int val) {
	60	blk[0 * DSIZE] = blk[1 * DSIZE] = blk[2 * DSIZE] = blk[3 * DSIZE]
	61	= blk[4 * DSIZE] = blk[5 * DSIZE] = blk[6 * DSIZE] = blk[7 * DSIZE] = val;
	62	}
	63
	64	static inline void fillrow(int *blk, int val) {
65	blk[0] = blk[1] = blk[2] = blk[3]
66	= blk[4] = blk[5] = blk[6] = blk[7] = val;
67	}
68
69	void idct(int *block,int used_col) {
70	int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
71	int z5, z10, z11, z12, z13;
72	int *ptr;
73	int i;
74
75	// the block has only the DC coefficient
76	if (used_col == -1) {
77	int v = block[0];
78	for (i = 0; i < DSIZE2; i++) block[i] = v;
79	return;
80	}
81
82	// last_col keeps track of the highest column with non zero coefficients
83	ptr = block;
84	for (i = 0; i < DSIZE; i++, ptr++) {
85	if ((used_col & (1 << i)) == 0) {
86	// the column is empty or has only the DC coefficient
87	if (ptr[DSIZE * 0]) {
88	fillcol(ptr, ptr[0]);
89	used_col \|= (1 << i);
90	}
91	continue;
92	}
93
94	// further optimization could be made by keeping track of
95	// last_row in rl2blk
96	z10 = ptr[DSIZE * 0] + ptr[DSIZE * 4]; // s04
97	z11 = ptr[DSIZE * 0] - ptr[DSIZE * 4]; // d04
98	z13 = ptr[DSIZE * 2] + ptr[DSIZE * 6]; // s26
99	z12 = MULS(ptr[DSIZE * 2] - ptr[DSIZE * 6], FIX_1_414213562) - z13;
100	//^^^^ d26=d262A4-s26
101
102	tmp0 = z10 + z13; // os07 = s04 + s26
103	tmp3 = z10 - z13; // os34 = s04 - s26
104	tmp1 = z11 + z12; // os16 = d04 + d26
105	tmp2 = z11 - z12; // os25 = d04 - d26
106
107	z13 = ptr[DSIZE * 3] + ptr[DSIZE * 5]; //s53
108	z10 = ptr[DSIZE * 3] - ptr[DSIZE * 5]; //-d53
109	z11 = ptr[DSIZE * 1] + ptr[DSIZE * 7]; //s17
110	z12 = ptr[DSIZE * 1] - ptr[DSIZE * 7]; //d17
111
112	tmp7 = z11 + z13; // od07 = s17 + s53
113
114	z5 = (z12 - z10) * (FIX_1_847759065);
115	tmp6 = SCALE(z10*(FIX_2_613125930) + z5, AAN_CONST_BITS) - tmp7;
116	tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
117	tmp4 = SCALE(z12*(FIX_1_082392200) - z5, AAN_CONST_BITS) + tmp5;
118
119	// path #1
120	//z5 = (z12 - z10)* FIX_1_847759065;
121	// tmp0 = (d17 + d53) * 2*A2
122
123	//tmp6 = DESCALE(z10*FIX_2_613125930 + z5, CONST_BITS) - tmp7;
124	// od16 = (d53-2B2 + tmp0) - od07
125
126	//tmp4 = DESCALE(z12*FIX_1_082392200 - z5, CONST_BITS) + tmp5;
127	// od34 = (d172B6 - tmp0) + od25
128
129	// path #2
130
131	// od34 = d172(B6-A2) - d532A2
132	// od16 = d532(A2-B2) + d172A2
133
134	// end
135
136	// tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
137	// od25 = (s17 - s53)2A4 - od16
138
139	ptr[DSIZE * 0] = (tmp0 + tmp7); // os07 + od07
140	ptr[DSIZE * 7] = (tmp0 - tmp7); // os07 - od07
141	ptr[DSIZE * 1] = (tmp1 + tmp6); // os16 + od16
142	ptr[DSIZE * 6] = (tmp1 - tmp6); // os16 - od16
143	ptr[DSIZE * 2] = (tmp2 + tmp5); // os25 + od25
144	ptr[DSIZE * 5] = (tmp2 - tmp5); // os25 - od25
145	ptr[DSIZE * 4] = (tmp3 + tmp4); // os34 + od34
146	ptr[DSIZE * 3] = (tmp3 - tmp4); // os34 - od34
147	}
148
149	ptr = block;
150	if (used_col == 1) {
151	for (i = 0; i < DSIZE; i++)
152	fillrow(block + DSIZE * i, block[DSIZE * i]);
153	} else {
154	for (i = 0; i < DSIZE; i++, ptr += DSIZE) {
155	z10 = ptr[0] + ptr[4];
156	z11 = ptr[0] - ptr[4];
157	z13 = ptr[2] + ptr[6];
158	z12 = MULS(ptr[2] - ptr[6], FIX_1_414213562) - z13;
159
160	tmp0 = z10 + z13;
161	tmp3 = z10 - z13;
162	tmp1 = z11 + z12;
163	tmp2 = z11 - z12;
164
165	z13 = ptr[3] + ptr[5];
166	z10 = ptr[3] - ptr[5];
167	z11 = ptr[1] + ptr[7];
168	z12 = ptr[1] - ptr[7];
169
170	tmp7 = z11 + z13;
171	z5 = (z12 - z10) * FIX_1_847759065;
172	tmp6 = SCALE(z10 * FIX_2_613125930 + z5, AAN_CONST_BITS) - tmp7;
173	tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
174	tmp4 = SCALE(z12 * FIX_1_082392200 - z5, AAN_CONST_BITS) + tmp5;
175
176	ptr[0] = tmp0 + tmp7;
177
178	ptr[7] = tmp0 - tmp7;
179	ptr[1] = tmp1 + tmp6;
180	ptr[6] = tmp1 - tmp6;
181	ptr[2] = tmp2 + tmp5;
182	ptr[5] = tmp2 - tmp5;
183	ptr[4] = tmp3 + tmp4;
184	ptr[3] = tmp3 - tmp4;
185	}
186	}
187	}
188
189	// mdec0: command register
190	#define MDEC0_STP 0x02000000
191	#define MDEC0_RGB24 0x08000000
192	#define MDEC0_SIZE_MASK 0xFFFF
193
194	// mdec1: status register
195	#define MDEC1_BUSY 0x20000000
196	#define MDEC1_DREQ 0x18000000
197	#define MDEC1_FIFO 0xc0000000
198	#define MDEC1_RGB24 0x02000000
199	#define MDEC1_STP 0x00800000
200	#define MDEC1_RESET 0x80000000
201
202	struct {
203	u32 reg0;
204	u32 reg1;
205	unsigned short *rl;
206	int rlsize;
207	} mdec;
208
209	static int iq_y[DSIZE2], iq_uv[DSIZE2];
210
211	static int zscan[DSIZE2] = {
212	0 , 1 , 8 , 16, 9 , 2 , 3 , 10,
213	17, 24, 32, 25, 18, 11, 4 , 5 ,
214	12, 19, 26, 33, 40, 48, 41, 34,
215	27, 20, 13, 6 , 7 , 14, 21, 28,
216	35, 42, 49, 56, 57, 50, 43, 36,
217	29, 22, 15, 23, 30, 37, 44, 51,
218	58, 59, 52, 45, 38, 31, 39, 46,
219	53, 60, 61, 54, 47, 55, 62, 63
220	};
221
222	static int aanscales[DSIZE2] = {
223	1048576, 1454417, 1370031, 1232995, 1048576, 823861, 567485, 289301,
224	1454417, 2017334, 1900287, 1710213, 1454417, 1142728, 787125, 401273,
225	1370031, 1900287, 1790031, 1610986, 1370031, 1076426, 741455, 377991,
226	1232995, 1710213, 1610986, 1449849, 1232995, 968758, 667292, 340183,
227	1048576, 1454417, 1370031, 1232995, 1048576, 823861, 567485, 289301,
228	823861, 1142728, 1076426, 968758, 823861, 647303, 445870, 227303,
229	567485, 787125, 741455, 667292, 567485, 445870, 307121, 156569,
230	289301, 401273, 377991, 340183, 289301, 227303, 156569, 79818
231	};
232
233	static void iqtab_init(int iqtab, unsigned char iq_y) {
234	int i;
235
236	for (i = 0; i < DSIZE2; i++) {
237	iqtab[i] = (iq_y[i] * SCALER(aanscales[zscan[i]], AAN_PRESCALE_SCALE));
238	}
239	}
240
241	#define MDEC_END_OF_DATA 0xfe00
242
243	unsigned short rl2blk(int blk, unsigned short *mdec_rl) {
244	int i, k, q_scale, rl, used_col;
245	int *iqtab;
246
247	memset(blk, 0, 6 * DSIZE2 * sizeof(int));
248	iqtab = iq_uv;
249	for (i = 0; i < 6; i++) {
250	// decode blocks (Cr,Cb,Y1,Y2,Y3,Y4)
251	if (i == 2) iqtab = iq_y;
252
253	rl = SWAP16(*mdec_rl); mdec_rl++;
254	q_scale = RLE_RUN(rl);
255	blk[0] = SCALER(iqtab[0] * RLE_VAL(rl), AAN_EXTRA - 3);
256	for (k = 0, used_col = 0;;) {
257	rl = SWAP16(*mdec_rl); mdec_rl++;
258	if (rl == MDEC_END_OF_DATA) break;
259	k += RLE_RUN(rl) + 1; // skip zero-coefficients
260
261	if (k > 63) {
262	// printf("run lenght exceeded 64 enties\n");
263	break;
264	}
265
266	// zigzag transformation
267	blk[zscan[k]] = SCALER(RLE_VAL(rl) * iqtab[k] * q_scale, AAN_EXTRA);
268	// keep track of used columns to speed up the idtc
269	used_col \|= (zscan[k] > 7) ? 1 << (zscan[k] & 7) : 0;
270	}
271
272	if (k == 0) used_col = -1;
273	// used_col is -1 for blocks with only the DC coefficient
274	// any other value is a bitmask of the columns that have
275	// at least one non zero cofficient in the rows 1-7
276	// single coefficients in row 0 are treted specially
277	// in the idtc function
278	idct(blk, used_col);
279	blk += DSIZE2;
280	}
281	return mdec_rl;
282	}
283
284	// full scale (JPEG)
285	// Y/Cb/Cr[0...255] -> R/G/B[0...255]
286	// R = 1.000 * (Y) + 1.400 * (Cr - 128)
287	// G = 1.000 * (Y) - 0.343 * (Cb - 128) - 0.711 (Cr - 128)
288	// B = 1.000 * (Y) + 1.765 * (Cb - 128)
289	#define MULR(a) ((1434 * (a)))
290	#define MULB(a) ((1807 * (a)))
291	#define MULG2(a, b) ((-351 * (a) - 728 * (b)))
292	#define MULY(a) ((a) << 10)
293
294	#define MAKERGB15(r, g, b, a) (SWAP16(a \| ((b) << 10) \| ((g) << 5) \| (r)))
295	#define SCALE8(c) SCALER(c, 20)
296	#define SCALE5(c) SCALER(c, 23)
297
298	#define CLAMP5(c) ( ((c) < -16) ? 0 : (((c) > (31 - 16)) ? 31 : ((c) + 16)) )
299	#define CLAMP8(c) ( ((c) < -128) ? 0 : (((c) > (255 - 128)) ? 255 : ((c) + 128)) )
300
301	#define CLAMP_SCALE8(a) (CLAMP8(SCALE8(a)))
302	#define CLAMP_SCALE5(a) (CLAMP5(SCALE5(a)))
303
304	static inline void putlinebw15(unsigned short image, int Yblk) {
305	int i;
306	int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
307
308	for (i = 0; i < 8; i++, Yblk++) {
309	int Y = *Yblk;
310	// missing rounding
311	image[i] = SWAP16((CLAMP5(Y >> 3) * 0x421) \| A);
312	}
313	}
314
315	static void putquadrgb15(unsigned short image, int Yblk, int Cr, int Cb) {
316	int Y, R, G, B;
317	int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
318	R = MULR(Cr);
319	G = MULG2(Cb, Cr);
320	B = MULB(Cb);
321
322	// added transparency
323	Y = MULY(Yblk[0]);
324	image[0] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
325	Y = MULY(Yblk[1]);
326	image[1] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
327	Y = MULY(Yblk[8]);
328	image[16] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
329	Y = MULY(Yblk[9]);
330	image[17] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
331	}
332
333	static void yuv2rgb15(int blk, unsigned short image) {
334	int x, y;
335	int Yblk = blk + DSIZE2 2;
336	int *Crblk = blk;
337	int *Cbblk = blk + DSIZE2;
338
339	if (!Config.Mdec) {
340	for (y = 0; y < 16; y += 2, Crblk += 4, Cbblk += 4, Yblk += 8, image += 24) {
341	if (y == 8) Yblk += DSIZE2;
342	for (x = 0; x < 4; x++, image += 2, Crblk++, Cbblk++, Yblk += 2) {
343	putquadrgb15(image, Yblk, Crblk, Cbblk);
344	putquadrgb15(image + 8, Yblk + DSIZE2, (Crblk + 4), (Cbblk + 4));
345	}
346	}
347	} else {
348	for (y = 0; y < 16; y++, Yblk += 8, image += 16) {
349	if (y == 8) Yblk += DSIZE2;
350	putlinebw15(image, Yblk);
351	putlinebw15(image + 8, Yblk + DSIZE2);
352	}
353	}
354	}
355
356	static inline void putlinebw24(unsigned char image, int Yblk) {
357	int i;
358	unsigned char Y;
359	for (i = 0; i < 8 * 3; i += 3, Yblk++) {
360	Y = CLAMP8(*Yblk);
361	image[i + 0] = Y;
362	image[i + 1] = Y;
363	image[i + 2] = Y;
364	}
365	}
366
367	static void putquadrgb24(unsigned char image, int Yblk, int Cr, int Cb) {
368	int Y, R, G, B;
369
370	R = MULR(Cr);
371	G = MULG2(Cb,Cr);
372	B = MULB(Cb);
373
374	Y = MULY(Yblk[0]);
375	image[0 * 3 + 0] = CLAMP_SCALE8(Y + R);
376	image[0 * 3 + 1] = CLAMP_SCALE8(Y + G);
377	image[0 * 3 + 2] = CLAMP_SCALE8(Y + B);
378	Y = MULY(Yblk[1]);
379	image[1 * 3 + 0] = CLAMP_SCALE8(Y + R);
380	image[1 * 3 + 1] = CLAMP_SCALE8(Y + G);
381	image[1 * 3 + 2] = CLAMP_SCALE8(Y + B);
382	Y = MULY(Yblk[8]);
383	image[16 * 3 + 0] = CLAMP_SCALE8(Y + R);
384	image[16 * 3 + 1] = CLAMP_SCALE8(Y + G);
385	image[16 * 3 + 2] = CLAMP_SCALE8(Y + B);
386	Y = MULY(Yblk[9]);
387	image[17 * 3 + 0] = CLAMP_SCALE8(Y + R);
388	image[17 * 3 + 1] = CLAMP_SCALE8(Y + G);
389	image[17 * 3 + 2] = CLAMP_SCALE8(Y + B);
390	}
391
392	static void yuv2rgb24(int blk, unsigned char image) {
393	int x, y;
394	int Yblk = blk + DSIZE2 2;
395	int *Crblk = blk;
396	int *Cbblk = blk + DSIZE2;
397
398	if (!Config.Mdec) {
399	for (y = 0; y < 16; y += 2, Crblk += 4, Cbblk += 4, Yblk += 8, image += 24 * 3) {
400	if (y == 8) Yblk += DSIZE2;
401	for (x = 0; x < 4; x++, image += 6, Crblk++, Cbblk++, Yblk += 2) {
402	putquadrgb24(image, Yblk, Crblk, Cbblk);
403	putquadrgb24(image + 8 * 3, Yblk + DSIZE2, (Crblk + 4), (Cbblk + 4));
404	}
405	}
406	} else {
407	for (y = 0; y < 16; y++, Yblk += 8, image += 16 * 3) {
408	if (y == 8) Yblk += DSIZE2;
409	putlinebw24(image, Yblk);
410	putlinebw24(image + 8 * 3, Yblk + DSIZE2);
411	}
412	}
413	}
414
415	void mdecInit(void) {
416	mdec.rl = (u16 *)&psxM[0x100000];
417	mdec.reg0 = 0;
418	mdec.reg1 = 0;
419	}
420
421	// command register
422	void mdecWrite0(u32 data) {
423	#ifdef CDR_LOG
424	CDR_LOG("mdec0 write %08x\n", data);
425	#endif
426	mdec.reg0 = data;
427	}
428
429	u32 mdecRead0(void) {
430	#ifdef CDR_LOG
431	CDR_LOG("mdec0 read %08x\n", mdec.reg0);
432	#endif
433	// mame is returning 0
434	return mdec.reg0;
435	}
436
437	// status register
438	void mdecWrite1(u32 data) {
439	#ifdef CDR_LOG
440	CDR_LOG("mdec1 write %08x\n", data);
441	#endif
442	if (data & MDEC1_RESET) { // mdec reset
443	mdec.reg0 = 0;
444	mdec.reg1 = 0;
445	}
446	}
447
448	u32 mdecRead1(void) {
449	u32 v = mdec.reg1;
450	v \|= (mdec.reg0 & MDEC0_STP) ? MDEC1_STP : 0;
451	v \|= (mdec.reg0 & MDEC0_RGB24) ? MDEC1_RGB24 : 0;
452	#ifdef CDR_LOG
453	CDR_LOG("mdec1 read %08x\n", v);
454	#endif
455	return v;
456	}
457
458	void psxDma0(u32 adr, u32 bcr, u32 chcr) {
459	int cmd = mdec.reg0;
460	int size;
461
462	#ifdef CDR_LOG
463	CDR_LOG("DMA0 %08x %08x %08x\n", adr, bcr, chcr);
464	#endif
465
466	if (chcr != 0x01000201) {
467	// printf("chcr != 0x01000201\n");
468	return;
469	}
470
471	size = (bcr >> 16) * (bcr & 0xffff);
472
473	switch (cmd >> 28) {
474	case 0x3: // decode
475	mdec.rl = (u16 *)PSXM(adr);
476	mdec.rlsize = mdec.reg0 & MDEC0_SIZE_MASK;
477	break;
478
479	case 0x4: // quantization table upload
480	{
481	u8 p = (u8 )PSXM(adr);
482	// printf("uploading new quantization table\n");
483	// printmatrixu8(p);
484	// printmatrixu8(p + 64);
485	iqtab_init(iq_y, p);
486	iqtab_init(iq_uv, p + 64);
487	}
488	break;
489
490	case 0x6: // cosine table
491	// printf("mdec cosine table\n");
492	break;
493
494	default:
495	// printf("mdec unknown command\n");
496	break;
497	}
498
499	HW_DMA0_CHCR &= SWAP32(~0x01000000);
500	DMA_INTERRUPT(0);
501	}
502
503	void psxDma1(u32 adr, u32 bcr, u32 chcr) {
504	int blk[DSIZE2 * 6];
505	unsigned short *image;
506	int size;
507
508	#ifdef CDR_LOG
509	CDR_LOG("DMA1 %08x %08x %08x (cmd = %08x)\n", adr, bcr, chcr, mdec.reg0);
510	#endif
511
512	if (chcr != 0x01000200) return;
513
514	size = (bcr >> 16) * (bcr & 0xffff);
515
516	image = (u16 *)PSXM(adr);
517
518	if (mdec.reg0 & MDEC0_RGB24) { // 15-b decoding
519	// MDECOUTDMA_INT(((size * (1000000 / 9000)) / 4) /** 4*/);
520	MDECOUTDMA_INT(size / 4);
521	size = size / ((16 * 16) / 2);
522	for (; size > 0; size--, image += (16 * 16)) {
523	mdec.rl = rl2blk(blk, mdec.rl);
524	yuv2rgb15(blk, image);
525	}
526	} else { // 24-b decoding
527	// MDECOUTDMA_INT(((size * (1000000 / 9000)) / 4) /** 4*/);
528	MDECOUTDMA_INT(size / 4);
529	size = size / ((24 * 16) / 2);
530	for (; size > 0; size--, image += (24 * 16)) {
531	mdec.rl = rl2blk(blk, mdec.rl);
532	yuv2rgb24(blk, (u8 *)image);
533	}
534	}
535
536	mdec.reg1 \|= MDEC1_BUSY;
537	}
538
539	void mdec1Interrupt() {
540	#ifdef CDR_LOG
541	CDR_LOG("mdec1Interrupt\n");
542	#endif
543	if (HW_DMA1_CHCR & SWAP32(0x01000000)) {
544	// Set a fixed value totaly arbitrarie another sound value is
545	// PSXCLK / 60 or PSXCLK / 50 since the bug happened at end of frame.
546	// PSXCLK / 1000 seems good for FF9. (for FF9 need < ~28000)
547	// CAUTION: commented interrupt-handling may lead to problems, keep an eye ;-)
548	MDECOUTDMA_INT(PSXCLK / 1000 * BIAS);
549	// psxRegs.interrupt \|= 0x02000000;
550	// psxRegs.intCycle[5 + 24 + 1] *= 8;
551	// psxRegs.intCycle[5 + 24] = psxRegs.cycle;
552	HW_DMA1_CHCR &= SWAP32(~0x01000000);
553	DMA_INTERRUPT(1);
554	} else {
555	mdec.reg1 &= ~MDEC1_BUSY;
556	}
557	}
558
559	int mdecFreeze(gzFile f, int Mode) {
560	gzfreeze(&mdec, sizeof(mdec));
561	gzfreeze(iq_y, sizeof(iq_y));
562	gzfreeze(iq_uv, sizeof(iq_uv));
563
564	return 0;
565	}