[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"

/* memory speed is 1 byte per MDEC_BIAS psx clock
 * That mean (PSXCLK / MDEC_BIAS) B/s
 * MDEC_BIAS = 2.0 => ~16MB/s
 * MDEC_BIAS = 3.0 => ~11MB/s
 * and so on ...
 * I guess I have 50 images in 50Hz ... (could be 25 images ?)
 * 320x240x24@50Hz => 11.52 MB/s
 * 320x240x24@60Hz => 13.824 MB/s
 * 320x240x16@50Hz => 7.68 MB/s
 * 320x240x16@60Hz => 9.216 MB/s
 * so 2.0 to 4.0 should be fine.
 */
 
/*
 * >= 14 for Sol Divide
 * <= 18 for "Disney's Treasure Planet"
 * Psychic Detective may break on *any* change
 */
#define MDEC_BIAS 14
#define MDEC_DELAY 1024

#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;
}

static 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		0x0000FFFF

// 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 _pending_dma1 {
	u32 adr;
	u32 bcr;
	u32 chcr;
};

static struct {
	u32 reg0;
	u32 reg1;
	const u16 * rl;
	const u16 * rl_end;
	u8 * block_buffer_pos;
	u8 block_buffer[16*16*3];
	struct _pending_dma1 pending_dma1;
} 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, const 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

static const unsigned short *rl2blk(int *blk, const 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)

static inline int clamp5(int v)
{
	v += 16;
	v = v < 0 ? 0 : (v > 31 ? 31 : v);
	return v;
}

static inline int clamp8(int v)
{
	v += 128;
	v = v < 0 ? 0 : (v > 255 ? 255 : v);
	return v;
}

#define CLAMP_SCALE8(a)   (clamp8(SCALE8(a)))
#define CLAMP_SCALE5(a)   (clamp5(SCALE5(a)))

static inline void putlinebw15(u16 *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 inline void putquadrgb15(u16 *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 inline 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(u8 * 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 inline void putquadrgb24(u8 * 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, u8 *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 += 8 * 3 * 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) {
	memset(&mdec, 0, sizeof(mdec));
	memset(iq_y, 0, sizeof(iq_y));
	memset(iq_uv, 0, sizeof(iq_uv));
	mdec.rl = (u16 *)&psxM[0x100000];
}

// command register
void mdecWrite0(u32 data) {
	mdec.reg0 = data;
}

u32 mdecRead0(void) {
	return mdec.reg0;
}

// status register
void mdecWrite1(u32 data) {
	if (data & MDEC1_RESET) { // mdec reset
		mdec.reg0 = 0;
		mdec.reg1 = 0;
		mdec.pending_dma1.adr = 0;
		mdec.block_buffer_pos = 0;
	}
}

u32 mdecRead1(void) {
	u32 v = mdec.reg1;
	return v;
}

void psxDma0(u32 adr, u32 bcr, u32 chcr) {
	u32 cmd = mdec.reg0, words_max = 0;
	const void *mem;
	int size;

	if (chcr != 0x01000201) {
		log_unhandled("mdec0: invalid dma %08x\n", chcr);
		return;
	}

	/* mdec is STP till dma0 is released */
	mdec.reg1 |= MDEC1_STP;

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

	adr &= ~3;
	mem = getDmaRam(adr, &words_max);
	if (mem == INVALID_PTR || size > words_max) {
		log_unhandled("bad dma0 madr %x\n", adr);
		HW_DMA0_CHCR &= SWAP32(~0x01000000);
		return;
	}

	switch (cmd >> 28) {
		case 0x3: // decode 15/24bpp
			mdec.rl = mem;
			/* now the mdec is busy till all data are decoded */
			mdec.reg1 |= MDEC1_BUSY;
			/* detect the end of decoding */
			mdec.rl_end = mdec.rl + (size * 2);

			/* sanity check */
			if(mdec.rl_end <= mdec.rl)
				break;

			/* process the pending dma1 */
			if(mdec.pending_dma1.adr){
				psxDma1(mdec.pending_dma1.adr, mdec.pending_dma1.bcr, mdec.pending_dma1.chcr);
			}
			mdec.pending_dma1.adr = 0;
			return;
			

		case 0x4: // quantization table upload
			{
				const u8 *p = mem;
				// 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:
			log_unhandled("mdec: unknown command %08x\n", cmd);
			break;
	}

	set_event(PSXINT_MDECINDMA, size);
}

void mdec0Interrupt()
{
	if (HW_DMA0_CHCR & SWAP32(0x01000000))
	{
		HW_DMA0_CHCR &= SWAP32(~0x01000000);
		DMA_INTERRUPT(0);
	}
}

#define SIZE_OF_24B_BLOCK (16*16*3)
#define SIZE_OF_16B_BLOCK (16*16*2)

void psxDma1(u32 adr, u32 bcr, u32 chcr) {
	u32 words, words_max = 0;
	int blk[DSIZE2 * 6];
	u8 * image;
	int size;

	if (chcr != 0x01000200) {
		log_unhandled("mdec1: invalid dma %08x\n", chcr);
		return;
	}

	words = (bcr >> 16) * (bcr & 0xffff);
	/* size in byte */
	size = words * 4;

	if (!(mdec.reg1 & MDEC1_BUSY)) {
		/* add to pending */
		mdec.pending_dma1.adr = adr;
		mdec.pending_dma1.bcr = bcr;
		mdec.pending_dma1.chcr = chcr;
		/* do not free the dma */
		return;
	}

	adr &= ~3;
	image = getDmaRam(adr, &words_max);
	if (image == INVALID_PTR || words > words_max) {
		log_unhandled("bad dma1 madr %x\n", adr);
		HW_DMA1_CHCR &= SWAP32(~0x01000000);
		return;
	}

	if (mdec.reg0 & MDEC0_RGB24) {
		/* 16 bits decoding
		 * block are 16 px * 16 px, each px are 2 byte
		 */

		/* there is some partial block pending ? */
		if(mdec.block_buffer_pos != 0) {
			int n = mdec.block_buffer - mdec.block_buffer_pos + SIZE_OF_16B_BLOCK;
			/* TODO: check if partial block do not  larger than size */
			memcpy(image, mdec.block_buffer_pos, n);
			image += n;
			size -= n;
			mdec.block_buffer_pos = 0;
		}

		while(size >= SIZE_OF_16B_BLOCK) {
			mdec.rl = rl2blk(blk, mdec.rl);
			yuv2rgb15(blk, (u16 *)image);
			image += SIZE_OF_16B_BLOCK;
			size -= SIZE_OF_16B_BLOCK;
		}

		if(size != 0) {
			mdec.rl = rl2blk(blk, mdec.rl);
			yuv2rgb15(blk, (u16 *)mdec.block_buffer);
			memcpy(image, mdec.block_buffer, size);
			mdec.block_buffer_pos = mdec.block_buffer + size;
		}

	} else {
		/* 24 bits decoding
		 * block are 16 px * 16 px, each px are 3 byte
		 */

		/* there is some partial block pending ? */
		if(mdec.block_buffer_pos != 0) {
			int n = mdec.block_buffer - mdec.block_buffer_pos + SIZE_OF_24B_BLOCK;
			/* TODO: check if partial block do not  larger than size */
			memcpy(image, mdec.block_buffer_pos, n);
			image += n;
			size -= n;
			mdec.block_buffer_pos = 0;
		}

		while(size >= SIZE_OF_24B_BLOCK) {
			mdec.rl = rl2blk(blk, mdec.rl);
			yuv2rgb24(blk, image);
			image += SIZE_OF_24B_BLOCK;
			size -= SIZE_OF_24B_BLOCK;
		}

		if(size != 0) {
			mdec.rl = rl2blk(blk, mdec.rl);
			yuv2rgb24(blk, mdec.block_buffer);
			memcpy(image, mdec.block_buffer, size);
			mdec.block_buffer_pos = mdec.block_buffer + size;
		}
	}
	if (size < 0)
		log_unhandled("mdec: bork\n");
	
	/* define the power of mdec */
	set_event(PSXINT_MDECOUTDMA, words * MDEC_BIAS + MDEC_DELAY);
	/* some CPU stalling */
	psxRegs.cycle += words * MDEC_BIAS / 4;
}

void mdec1Interrupt() {
	/* Author : gschwind
	 *
	 * in that case we have done all decoding stuff
	 * Note that : each block end with 0xfe00 flags
	 * the list of blocks end with the same 0xfe00 flags
	 * data loock like :
	 *
	 *  data block ...
	 *  0xfe00
	 *  data block ...
	 *  0xfe00
	 *  a lost of block ..
	 *
	 *  0xfe00
	 *  the last block
	 *  0xfe00
	 *  0xfe00
	 *
	 * OR
	 *
	 * if the 0xfe00 is not present the data size is important.
	 *
	 */

	/* MDEC_END_OF_DATA avoids read outside memory */
	//printf("mdec left %zd, v=%04x\n", mdec.rl_end - mdec.rl, *(mdec.rl));
	if (mdec.rl >= mdec.rl_end || SWAP16(*(mdec.rl)) == MDEC_END_OF_DATA) {
		mdec.reg1 &= ~(MDEC1_STP|MDEC1_BUSY);
		if (HW_DMA0_CHCR & SWAP32(0x01000000))
		{
			HW_DMA0_CHCR &= SWAP32(~0x01000000);
			DMA_INTERRUPT(0);
		}
	}

	if (HW_DMA1_CHCR & SWAP32(0x01000000))
	{
		HW_DMA1_CHCR &= SWAP32(~0x01000000);
		DMA_INTERRUPT(1);
	}
}

int mdecFreeze(void *f, int Mode) {
	u8 *base = (u8 *)psxM;
	u32 v;

	gzfreeze(&mdec.reg0, sizeof(mdec.reg0));
	gzfreeze(&mdec.reg1, sizeof(mdec.reg1));

	v = (u8 *)mdec.rl - base;
	gzfreeze(&v, sizeof(v));
	mdec.rl = (u16 *)(base + (v & 0x1ffffe));
	v = (u8 *)mdec.rl_end - base;
	gzfreeze(&v, sizeof(v));
	mdec.rl_end = (u16 *)(base + (v & 0x1ffffe));

	v = 0;
	if (mdec.block_buffer_pos)
		v = mdec.block_buffer_pos - mdec.block_buffer;
	gzfreeze(&v, sizeof(v));
	mdec.block_buffer_pos = 0;
	if (v && v < sizeof(mdec.block_buffer))
		mdec.block_buffer_pos = mdec.block_buffer;

	gzfreeze(&mdec.block_buffer, sizeof(mdec.block_buffer));
	gzfreeze(&mdec.pending_dma1, sizeof(mdec.pending_dma1));
	gzfreeze(iq_y, sizeof(iq_y));
	gzfreeze(iq_uv, sizeof(iq_uv));

	return 0;
}
Commit	Line	Data
	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	/* memory speed is 1 byte per MDEC_BIAS psx clock
	24	* That mean (PSXCLK / MDEC_BIAS) B/s
	25	* MDEC_BIAS = 2.0 => ~16MB/s
	26	* MDEC_BIAS = 3.0 => ~11MB/s
	27	* and so on ...
	28	* I guess I have 50 images in 50Hz ... (could be 25 images ?)
	29	* 320x240x24@50Hz => 11.52 MB/s
	30	* 320x240x24@60Hz => 13.824 MB/s
	31	* 320x240x16@50Hz => 7.68 MB/s
	32	* 320x240x16@60Hz => 9.216 MB/s
	33	* so 2.0 to 4.0 should be fine.
	34	*/
	35
	36	/*
	37	* >= 14 for Sol Divide
	38	* <= 18 for "Disney's Treasure Planet"
	39	* Psychic Detective may break on any change
	40	*/
	41	#define MDEC_BIAS 14
	42	#define MDEC_DELAY 1024
	43
	44	#define DSIZE 8
	45	#define DSIZE2 (DSIZE * DSIZE)
	46
	47	#define SCALE(x, n) ((x) >> (n))
	48	#define SCALER(x, n) (((x) + ((1 << (n)) >> 1)) >> (n))
	49
	50	#define AAN_CONST_BITS 12
	51	#define AAN_PRESCALE_BITS 16
	52
	53	#define AAN_CONST_SIZE 24
	54	#define AAN_CONST_SCALE (AAN_CONST_SIZE - AAN_CONST_BITS)
	55
	56	#define AAN_PRESCALE_SIZE 20
	57	#define AAN_PRESCALE_SCALE (AAN_PRESCALE_SIZE-AAN_PRESCALE_BITS)
	58	#define AAN_EXTRA 12
	59
	60	#define FIX_1_082392200 SCALER(18159528, AAN_CONST_SCALE) // B6
	61	#define FIX_1_414213562 SCALER(23726566, AAN_CONST_SCALE) // A4
	62	#define FIX_1_847759065 SCALER(31000253, AAN_CONST_SCALE) // A2
	63	#define FIX_2_613125930 SCALER(43840978, AAN_CONST_SCALE) // B2
	64
	65	#define MULS(var, const) (SCALE((var) * (const), AAN_CONST_BITS))
	66
	67	#define RLE_RUN(a) ((a) >> 10)
	68	#define RLE_VAL(a) (((int)(a) << (sizeof(int) * 8 - 10)) >> (sizeof(int) * 8 - 10))
	69
	70	#if 0
	71	static void printmatrixu8(u8 *m) {
	72	int i;
	73	for(i = 0; i < DSIZE2; i++) {
	74	printf("%3d ",m[i]);
	75	if((i+1) % 8 == 0) printf("\n");
	76	}
	77	}
	78	#endif
	79
	80	static inline void fillcol(int *blk, int val) {
	81	blk[0 * DSIZE] = blk[1 * DSIZE] = blk[2 * DSIZE] = blk[3 * DSIZE]
	82	= blk[4 * DSIZE] = blk[5 * DSIZE] = blk[6 * DSIZE] = blk[7 * DSIZE] = val;
	83	}
	84
	85	static inline void fillrow(int *blk, int val) {
	86	blk[0] = blk[1] = blk[2] = blk[3]
	87	= blk[4] = blk[5] = blk[6] = blk[7] = val;
	88	}
	89
	90	static void idct(int *block,int used_col) {
	91	int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
	92	int z5, z10, z11, z12, z13;
	93	int *ptr;
	94	int i;
	95
	96	// the block has only the DC coefficient
	97	if (used_col == -1) {
	98	int v = block[0];
	99	for (i = 0; i < DSIZE2; i++) block[i] = v;
	100	return;
	101	}
	102
	103	// last_col keeps track of the highest column with non zero coefficients
	104	ptr = block;
	105	for (i = 0; i < DSIZE; i++, ptr++) {
	106	if ((used_col & (1 << i)) == 0) {
	107	// the column is empty or has only the DC coefficient
	108	if (ptr[DSIZE * 0]) {
	109	fillcol(ptr, ptr[0]);
	110	used_col \|= (1 << i);
	111	}
	112	continue;
	113	}
	114
	115	// further optimization could be made by keeping track of
	116	// last_row in rl2blk
	117	z10 = ptr[DSIZE * 0] + ptr[DSIZE * 4]; // s04
	118	z11 = ptr[DSIZE * 0] - ptr[DSIZE * 4]; // d04
	119	z13 = ptr[DSIZE * 2] + ptr[DSIZE * 6]; // s26
	120	z12 = MULS(ptr[DSIZE * 2] - ptr[DSIZE * 6], FIX_1_414213562) - z13;
	121	//^^^^ d26=d262A4-s26
	122
	123	tmp0 = z10 + z13; // os07 = s04 + s26
	124	tmp3 = z10 - z13; // os34 = s04 - s26
	125	tmp1 = z11 + z12; // os16 = d04 + d26
	126	tmp2 = z11 - z12; // os25 = d04 - d26
	127
	128	z13 = ptr[DSIZE * 3] + ptr[DSIZE * 5]; //s53
	129	z10 = ptr[DSIZE * 3] - ptr[DSIZE * 5]; //-d53
	130	z11 = ptr[DSIZE * 1] + ptr[DSIZE * 7]; //s17
	131	z12 = ptr[DSIZE * 1] - ptr[DSIZE * 7]; //d17
	132
	133	tmp7 = z11 + z13; // od07 = s17 + s53
	134
	135	z5 = (z12 - z10) * (FIX_1_847759065);
	136	tmp6 = SCALE(z10*(FIX_2_613125930) + z5, AAN_CONST_BITS) - tmp7;
	137	tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
	138	tmp4 = SCALE(z12*(FIX_1_082392200) - z5, AAN_CONST_BITS) + tmp5;
	139
	140	// path #1
	141	//z5 = (z12 - z10)* FIX_1_847759065;
	142	// tmp0 = (d17 + d53) * 2*A2
	143
	144	//tmp6 = DESCALE(z10*FIX_2_613125930 + z5, CONST_BITS) - tmp7;
	145	// od16 = (d53-2B2 + tmp0) - od07
	146
	147	//tmp4 = DESCALE(z12*FIX_1_082392200 - z5, CONST_BITS) + tmp5;
	148	// od34 = (d172B6 - tmp0) + od25
	149
	150	// path #2
	151
	152	// od34 = d172(B6-A2) - d532A2
	153	// od16 = d532(A2-B2) + d172A2
	154
	155	// end
	156
	157	// tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
	158	// od25 = (s17 - s53)2A4 - od16
	159
	160	ptr[DSIZE * 0] = (tmp0 + tmp7); // os07 + od07
	161	ptr[DSIZE * 7] = (tmp0 - tmp7); // os07 - od07
	162	ptr[DSIZE * 1] = (tmp1 + tmp6); // os16 + od16
	163	ptr[DSIZE * 6] = (tmp1 - tmp6); // os16 - od16
	164	ptr[DSIZE * 2] = (tmp2 + tmp5); // os25 + od25
	165	ptr[DSIZE * 5] = (tmp2 - tmp5); // os25 - od25
	166	ptr[DSIZE * 4] = (tmp3 + tmp4); // os34 + od34
	167	ptr[DSIZE * 3] = (tmp3 - tmp4); // os34 - od34
	168	}
	169
	170	ptr = block;
	171	if (used_col == 1) {
	172	for (i = 0; i < DSIZE; i++)
	173	fillrow(block + DSIZE * i, block[DSIZE * i]);
	174	} else {
	175	for (i = 0; i < DSIZE; i++, ptr += DSIZE) {
	176	z10 = ptr[0] + ptr[4];
	177	z11 = ptr[0] - ptr[4];
	178	z13 = ptr[2] + ptr[6];
	179	z12 = MULS(ptr[2] - ptr[6], FIX_1_414213562) - z13;
	180
	181	tmp0 = z10 + z13;
	182	tmp3 = z10 - z13;
	183	tmp1 = z11 + z12;
	184	tmp2 = z11 - z12;
	185
	186	z13 = ptr[3] + ptr[5];
	187	z10 = ptr[3] - ptr[5];
	188	z11 = ptr[1] + ptr[7];
	189	z12 = ptr[1] - ptr[7];
	190
	191	tmp7 = z11 + z13;
	192	z5 = (z12 - z10) * FIX_1_847759065;
	193	tmp6 = SCALE(z10 * FIX_2_613125930 + z5, AAN_CONST_BITS) - tmp7;
	194	tmp5 = MULS(z11 - z13, FIX_1_414213562) - tmp6;
	195	tmp4 = SCALE(z12 * FIX_1_082392200 - z5, AAN_CONST_BITS) + tmp5;
	196
	197	ptr[0] = tmp0 + tmp7;
	198
	199	ptr[7] = tmp0 - tmp7;
	200	ptr[1] = tmp1 + tmp6;
	201	ptr[6] = tmp1 - tmp6;
	202	ptr[2] = tmp2 + tmp5;
	203	ptr[5] = tmp2 - tmp5;
	204	ptr[4] = tmp3 + tmp4;
	205	ptr[3] = tmp3 - tmp4;
	206	}
	207	}
	208	}
	209
	210	// mdec0: command register
	211	#define MDEC0_STP 0x02000000
	212	#define MDEC0_RGB24 0x08000000
	213	#define MDEC0_SIZE_MASK 0x0000FFFF
	214
	215	// mdec1: status register
	216	#define MDEC1_BUSY 0x20000000
	217	#define MDEC1_DREQ 0x18000000
	218	#define MDEC1_FIFO 0xc0000000
	219	#define MDEC1_RGB24 0x02000000
	220	#define MDEC1_STP 0x00800000
	221	#define MDEC1_RESET 0x80000000
	222
	223	struct _pending_dma1 {
	224	u32 adr;
	225	u32 bcr;
	226	u32 chcr;
	227	};
	228
	229	static struct {
	230	u32 reg0;
	231	u32 reg1;
	232	const u16 * rl;
	233	const u16 * rl_end;
	234	u8 * block_buffer_pos;
	235	u8 block_buffer[16163];
	236	struct _pending_dma1 pending_dma1;
	237	} mdec;
	238
	239	static int iq_y[DSIZE2], iq_uv[DSIZE2];
	240
	241	static int zscan[DSIZE2] = {
	242	0 , 1 , 8 , 16, 9 , 2 , 3 , 10,
	243	17, 24, 32, 25, 18, 11, 4 , 5 ,
	244	12, 19, 26, 33, 40, 48, 41, 34,
	245	27, 20, 13, 6 , 7 , 14, 21, 28,
	246	35, 42, 49, 56, 57, 50, 43, 36,
	247	29, 22, 15, 23, 30, 37, 44, 51,
	248	58, 59, 52, 45, 38, 31, 39, 46,
	249	53, 60, 61, 54, 47, 55, 62, 63
	250	};
	251
	252	static int aanscales[DSIZE2] = {
	253	1048576, 1454417, 1370031, 1232995, 1048576, 823861, 567485, 289301,
	254	1454417, 2017334, 1900287, 1710213, 1454417, 1142728, 787125, 401273,
	255	1370031, 1900287, 1790031, 1610986, 1370031, 1076426, 741455, 377991,
	256	1232995, 1710213, 1610986, 1449849, 1232995, 968758, 667292, 340183,
	257	1048576, 1454417, 1370031, 1232995, 1048576, 823861, 567485, 289301,
	258	823861, 1142728, 1076426, 968758, 823861, 647303, 445870, 227303,
	259	567485, 787125, 741455, 667292, 567485, 445870, 307121, 156569,
	260	289301, 401273, 377991, 340183, 289301, 227303, 156569, 79818
	261	};
	262
	263	static void iqtab_init(int iqtab, const unsigned char iq_y) {
	264	int i;
	265
	266	for (i = 0; i < DSIZE2; i++) {
	267	iqtab[i] = (iq_y[i] * SCALER(aanscales[zscan[i]], AAN_PRESCALE_SCALE));
	268	}
	269	}
	270
	271	#define MDEC_END_OF_DATA 0xfe00
	272
	273	static const unsigned short rl2blk(int blk, const unsigned short *mdec_rl) {
	274	int i, k, q_scale, rl, used_col;
	275	int *iqtab;
	276
	277	memset(blk, 0, 6 * DSIZE2 * sizeof(int));
	278	iqtab = iq_uv;
	279	for (i = 0; i < 6; i++) {
	280	// decode blocks (Cr,Cb,Y1,Y2,Y3,Y4)
	281	if (i == 2) iqtab = iq_y;
	282
	283	rl = SWAP16(*mdec_rl); mdec_rl++;
	284	q_scale = RLE_RUN(rl);
	285	blk[0] = SCALER(iqtab[0] * RLE_VAL(rl), AAN_EXTRA - 3);
	286	for (k = 0, used_col = 0;;) {
	287	rl = SWAP16(*mdec_rl); mdec_rl++;
	288	if (rl == MDEC_END_OF_DATA) break;
	289	k += RLE_RUN(rl) + 1; // skip zero-coefficients
	290
	291	if (k > 63) {
	292	// printf("run lenght exceeded 64 enties\n");
	293	break;
	294	}
	295
	296	// zigzag transformation
	297	blk[zscan[k]] = SCALER(RLE_VAL(rl) * iqtab[k] * q_scale, AAN_EXTRA);
	298	// keep track of used columns to speed up the idtc
	299	used_col \|= (zscan[k] > 7) ? 1 << (zscan[k] & 7) : 0;
	300	}
	301
	302	if (k == 0) used_col = -1;
	303	// used_col is -1 for blocks with only the DC coefficient
	304	// any other value is a bitmask of the columns that have
	305	// at least one non zero cofficient in the rows 1-7
	306	// single coefficients in row 0 are treted specially
	307	// in the idtc function
	308	idct(blk, used_col);
	309	blk += DSIZE2;
	310	}
	311	return mdec_rl;
	312	}
	313
	314	// full scale (JPEG)
	315	// Y/Cb/Cr[0...255] -> R/G/B[0...255]
	316	// R = 1.000 * (Y) + 1.400 * (Cr - 128)
	317	// G = 1.000 * (Y) - 0.343 * (Cb - 128) - 0.711 (Cr - 128)
	318	// B = 1.000 * (Y) + 1.765 * (Cb - 128)
	319	#define MULR(a) ((1434 * (a)))
	320	#define MULB(a) ((1807 * (a)))
	321	#define MULG2(a, b) ((-351 * (a) - 728 * (b)))
	322	#define MULY(a) ((a) << 10)
	323
	324	#define MAKERGB15(r, g, b, a) (SWAP16(a \| ((b) << 10) \| ((g) << 5) \| (r)))
	325	#define SCALE8(c) SCALER(c, 20)
	326	#define SCALE5(c) SCALER(c, 23)
	327
	328	static inline int clamp5(int v)
	329	{
	330	v += 16;
	331	v = v < 0 ? 0 : (v > 31 ? 31 : v);
	332	return v;
	333	}
	334
	335	static inline int clamp8(int v)
	336	{
	337	v += 128;
	338	v = v < 0 ? 0 : (v > 255 ? 255 : v);
	339	return v;
	340	}
	341
	342	#define CLAMP_SCALE8(a) (clamp8(SCALE8(a)))
	343	#define CLAMP_SCALE5(a) (clamp5(SCALE5(a)))
	344
	345	static inline void putlinebw15(u16 image, int Yblk) {
	346	int i;
	347	int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
	348
	349	for (i = 0; i < 8; i++, Yblk++) {
	350	int Y = *Yblk;
	351	// missing rounding
	352	image[i] = SWAP16((clamp5(Y >> 3) * 0x421) \| A);
	353	}
	354	}
	355
	356	static inline void putquadrgb15(u16 image, int Yblk, int Cr, int Cb) {
	357	int Y, R, G, B;
	358	int A = (mdec.reg0 & MDEC0_STP) ? 0x8000 : 0;
	359	R = MULR(Cr);
	360	G = MULG2(Cb, Cr);
	361	B = MULB(Cb);
	362
	363	// added transparency
	364	Y = MULY(Yblk[0]);
	365	image[0] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
	366	Y = MULY(Yblk[1]);
	367	image[1] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
	368	Y = MULY(Yblk[8]);
	369	image[16] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
	370	Y = MULY(Yblk[9]);
	371	image[17] = MAKERGB15(CLAMP_SCALE5(Y + R), CLAMP_SCALE5(Y + G), CLAMP_SCALE5(Y + B), A);
	372	}
	373
	374	static inline void yuv2rgb15(int blk, unsigned short image) {
	375	int x, y;
	376	int Yblk = blk + DSIZE2 2;
	377	int *Crblk = blk;
	378	int *Cbblk = blk + DSIZE2;
	379
	380	if (!Config.Mdec) {
	381	for (y = 0; y < 16; y += 2, Crblk += 4, Cbblk += 4, Yblk += 8, image += 24) {
	382	if (y == 8) Yblk += DSIZE2;
	383	for (x = 0; x < 4; x++, image += 2, Crblk++, Cbblk++, Yblk += 2) {
	384	putquadrgb15(image, Yblk, Crblk, Cbblk);
	385	putquadrgb15(image + 8, Yblk + DSIZE2, (Crblk + 4), (Cbblk + 4));
	386	}
	387	}
	388	} else {
	389	for (y = 0; y < 16; y++, Yblk += 8, image += 16) {
	390	if (y == 8) Yblk += DSIZE2;
	391	putlinebw15(image, Yblk);
	392	putlinebw15(image + 8, Yblk + DSIZE2);
	393	}
	394	}
	395	}
	396
	397	static inline void putlinebw24(u8 * image, int *Yblk) {
	398	int i;
	399	unsigned char Y;
	400	for (i = 0; i < 8 * 3; i += 3, Yblk++) {
	401	Y = clamp8(*Yblk);
	402	image[i + 0] = Y;
	403	image[i + 1] = Y;
	404	image[i + 2] = Y;
	405	}
	406	}
	407
	408	static inline void putquadrgb24(u8 * image, int *Yblk, int Cr, int Cb) {
	409	int Y, R, G, B;
	410
	411	R = MULR(Cr);
	412	G = MULG2(Cb,Cr);
	413	B = MULB(Cb);
	414
	415	Y = MULY(Yblk[0]);
	416	image[0 * 3 + 0] = CLAMP_SCALE8(Y + R);
	417	image[0 * 3 + 1] = CLAMP_SCALE8(Y + G);
	418	image[0 * 3 + 2] = CLAMP_SCALE8(Y + B);
	419	Y = MULY(Yblk[1]);
	420	image[1 * 3 + 0] = CLAMP_SCALE8(Y + R);
	421	image[1 * 3 + 1] = CLAMP_SCALE8(Y + G);
	422	image[1 * 3 + 2] = CLAMP_SCALE8(Y + B);
	423	Y = MULY(Yblk[8]);
	424	image[16 * 3 + 0] = CLAMP_SCALE8(Y + R);
	425	image[16 * 3 + 1] = CLAMP_SCALE8(Y + G);
	426	image[16 * 3 + 2] = CLAMP_SCALE8(Y + B);
	427	Y = MULY(Yblk[9]);
	428	image[17 * 3 + 0] = CLAMP_SCALE8(Y + R);
	429	image[17 * 3 + 1] = CLAMP_SCALE8(Y + G);
	430	image[17 * 3 + 2] = CLAMP_SCALE8(Y + B);
	431	}
	432
	433	static void yuv2rgb24(int blk, u8 image) {
	434	int x, y;
	435	int Yblk = blk + DSIZE2 2;
	436	int *Crblk = blk;
	437	int *Cbblk = blk + DSIZE2;
	438
	439	if (!Config.Mdec) {
	440	for (y = 0; y < 16; y += 2, Crblk += 4, Cbblk += 4, Yblk += 8, image += 8 * 3 * 3) {
	441	if (y == 8) Yblk += DSIZE2;
	442	for (x = 0; x < 4; x++, image += 6, Crblk++, Cbblk++, Yblk += 2) {
	443	putquadrgb24(image, Yblk, Crblk, Cbblk);
	444	putquadrgb24(image + 8 * 3, Yblk + DSIZE2, (Crblk + 4), (Cbblk + 4));
	445	}
	446	}
	447	} else {
	448	for (y = 0; y < 16; y++, Yblk += 8, image += 16 * 3) {
	449	if (y == 8) Yblk += DSIZE2;
	450	putlinebw24(image, Yblk);
	451	putlinebw24(image + 8 * 3, Yblk + DSIZE2);
	452	}
	453	}
	454	}
	455
	456	void mdecInit(void) {
	457	memset(&mdec, 0, sizeof(mdec));
	458	memset(iq_y, 0, sizeof(iq_y));
	459	memset(iq_uv, 0, sizeof(iq_uv));
	460	mdec.rl = (u16 *)&psxM[0x100000];
	461	}
	462
	463	// command register
	464	void mdecWrite0(u32 data) {
	465	mdec.reg0 = data;
	466	}
	467
	468	u32 mdecRead0(void) {
	469	return mdec.reg0;
	470	}
	471
	472	// status register
	473	void mdecWrite1(u32 data) {
	474	if (data & MDEC1_RESET) { // mdec reset
	475	mdec.reg0 = 0;
	476	mdec.reg1 = 0;
	477	mdec.pending_dma1.adr = 0;
	478	mdec.block_buffer_pos = 0;
	479	}
	480	}
	481
	482	u32 mdecRead1(void) {
	483	u32 v = mdec.reg1;
	484	return v;
	485	}
	486
	487	void psxDma0(u32 adr, u32 bcr, u32 chcr) {
	488	u32 cmd = mdec.reg0, words_max = 0;
	489	const void *mem;
	490	int size;
	491
	492	if (chcr != 0x01000201) {
	493	log_unhandled("mdec0: invalid dma %08x\n", chcr);
	494	return;
	495	}
	496
	497	/* mdec is STP till dma0 is released */
	498	mdec.reg1 \|= MDEC1_STP;
	499
	500	size = (bcr >> 16) * (bcr & 0xffff);
	501
	502	adr &= ~3;
	503	mem = getDmaRam(adr, &words_max);
	504	if (mem == INVALID_PTR \|\| size > words_max) {
	505	log_unhandled("bad dma0 madr %x\n", adr);
	506	HW_DMA0_CHCR &= SWAP32(~0x01000000);
	507	return;
	508	}
	509
	510	switch (cmd >> 28) {
	511	case 0x3: // decode 15/24bpp
	512	mdec.rl = mem;
	513	/* now the mdec is busy till all data are decoded */
	514	mdec.reg1 \|= MDEC1_BUSY;
	515	/* detect the end of decoding */
	516	mdec.rl_end = mdec.rl + (size * 2);
	517
	518	/* sanity check */
	519	if(mdec.rl_end <= mdec.rl)
	520	break;
	521
	522	/* process the pending dma1 */
	523	if(mdec.pending_dma1.adr){
	524	psxDma1(mdec.pending_dma1.adr, mdec.pending_dma1.bcr, mdec.pending_dma1.chcr);
	525	}
	526	mdec.pending_dma1.adr = 0;
	527	return;
	528
	529
	530	case 0x4: // quantization table upload
	531	{
	532	const u8 *p = mem;
	533	// printf("uploading new quantization table\n");
	534	// printmatrixu8(p);
	535	// printmatrixu8(p + 64);
	536	iqtab_init(iq_y, p);
	537	iqtab_init(iq_uv, p + 64);
	538	}
	539	break;
	540
	541	case 0x6: // cosine table
	542	// printf("mdec cosine table\n");
	543	break;
	544
	545	default:
	546	log_unhandled("mdec: unknown command %08x\n", cmd);
	547	break;
	548	}
	549
	550	set_event(PSXINT_MDECINDMA, size);
	551	}
	552
	553	void mdec0Interrupt()
	554	{
	555	if (HW_DMA0_CHCR & SWAP32(0x01000000))
	556	{
	557	HW_DMA0_CHCR &= SWAP32(~0x01000000);
	558	DMA_INTERRUPT(0);
	559	}
	560	}
	561
	562	#define SIZE_OF_24B_BLOCK (16163)
	563	#define SIZE_OF_16B_BLOCK (16162)
	564
	565	void psxDma1(u32 adr, u32 bcr, u32 chcr) {
	566	u32 words, words_max = 0;
	567	int blk[DSIZE2 * 6];
	568	u8 * image;
	569	int size;
	570
	571	if (chcr != 0x01000200) {
	572	log_unhandled("mdec1: invalid dma %08x\n", chcr);
	573	return;
	574	}
	575
	576	words = (bcr >> 16) * (bcr & 0xffff);
	577	/* size in byte */
	578	size = words * 4;
	579
	580	if (!(mdec.reg1 & MDEC1_BUSY)) {
	581	/* add to pending */
	582	mdec.pending_dma1.adr = adr;
	583	mdec.pending_dma1.bcr = bcr;
	584	mdec.pending_dma1.chcr = chcr;
	585	/* do not free the dma */
	586	return;
	587	}
	588
	589	adr &= ~3;
	590	image = getDmaRam(adr, &words_max);
	591	if (image == INVALID_PTR \|\| words > words_max) {
	592	log_unhandled("bad dma1 madr %x\n", adr);
	593	HW_DMA1_CHCR &= SWAP32(~0x01000000);
	594	return;
	595	}
	596
	597	if (mdec.reg0 & MDEC0_RGB24) {
	598	/* 16 bits decoding
	599	* block are 16 px * 16 px, each px are 2 byte
	600	*/
	601
	602	/* there is some partial block pending ? */
	603	if(mdec.block_buffer_pos != 0) {
	604	int n = mdec.block_buffer - mdec.block_buffer_pos + SIZE_OF_16B_BLOCK;
	605	/* TODO: check if partial block do not larger than size */
	606	memcpy(image, mdec.block_buffer_pos, n);
	607	image += n;
	608	size -= n;
	609	mdec.block_buffer_pos = 0;
	610	}
	611
	612	while(size >= SIZE_OF_16B_BLOCK) {
	613	mdec.rl = rl2blk(blk, mdec.rl);
	614	yuv2rgb15(blk, (u16 *)image);
	615	image += SIZE_OF_16B_BLOCK;
	616	size -= SIZE_OF_16B_BLOCK;
	617	}
	618
	619	if(size != 0) {
	620	mdec.rl = rl2blk(blk, mdec.rl);
	621	yuv2rgb15(blk, (u16 *)mdec.block_buffer);
	622	memcpy(image, mdec.block_buffer, size);
	623	mdec.block_buffer_pos = mdec.block_buffer + size;
	624	}
	625
	626	} else {
	627	/* 24 bits decoding
	628	* block are 16 px * 16 px, each px are 3 byte
	629	*/
	630
	631	/* there is some partial block pending ? */
	632	if(mdec.block_buffer_pos != 0) {
	633	int n = mdec.block_buffer - mdec.block_buffer_pos + SIZE_OF_24B_BLOCK;
	634	/* TODO: check if partial block do not larger than size */
	635	memcpy(image, mdec.block_buffer_pos, n);
	636	image += n;
	637	size -= n;
	638	mdec.block_buffer_pos = 0;
	639	}
	640
	641	while(size >= SIZE_OF_24B_BLOCK) {
	642	mdec.rl = rl2blk(blk, mdec.rl);
	643	yuv2rgb24(blk, image);
	644	image += SIZE_OF_24B_BLOCK;
	645	size -= SIZE_OF_24B_BLOCK;
	646	}
	647
	648	if(size != 0) {
	649	mdec.rl = rl2blk(blk, mdec.rl);
	650	yuv2rgb24(blk, mdec.block_buffer);
	651	memcpy(image, mdec.block_buffer, size);
	652	mdec.block_buffer_pos = mdec.block_buffer + size;
	653	}
	654	}
	655	if (size < 0)
	656	log_unhandled("mdec: bork\n");
	657
	658	/* define the power of mdec */
	659	set_event(PSXINT_MDECOUTDMA, words * MDEC_BIAS + MDEC_DELAY);
	660	/* some CPU stalling */
	661	psxRegs.cycle += words * MDEC_BIAS / 4;
	662	}
	663
	664	void mdec1Interrupt() {
	665	/* Author : gschwind
	666	*
	667	* in that case we have done all decoding stuff
	668	* Note that : each block end with 0xfe00 flags
	669	* the list of blocks end with the same 0xfe00 flags
	670	* data loock like :
	671	*
	672	* data block ...
	673	* 0xfe00
	674	* data block ...
	675	* 0xfe00
	676	* a lost of block ..
	677	*
	678	* 0xfe00
	679	* the last block
	680	* 0xfe00
	681	* 0xfe00
	682	*
	683	* OR
	684	*
	685	* if the 0xfe00 is not present the data size is important.
	686	*
	687	*/
	688
	689	/* MDEC_END_OF_DATA avoids read outside memory */
	690	//printf("mdec left %zd, v=%04x\n", mdec.rl_end - mdec.rl, *(mdec.rl));
	691	if (mdec.rl >= mdec.rl_end \|\| SWAP16(*(mdec.rl)) == MDEC_END_OF_DATA) {
	692	mdec.reg1 &= ~(MDEC1_STP\|MDEC1_BUSY);
	693	if (HW_DMA0_CHCR & SWAP32(0x01000000))
	694	{
	695	HW_DMA0_CHCR &= SWAP32(~0x01000000);
	696	DMA_INTERRUPT(0);
	697	}
	698	}
	699
	700	if (HW_DMA1_CHCR & SWAP32(0x01000000))
	701	{
	702	HW_DMA1_CHCR &= SWAP32(~0x01000000);
	703	DMA_INTERRUPT(1);
	704	}
	705	}
	706
	707	int mdecFreeze(void *f, int Mode) {
	708	u8 base = (u8 )psxM;
	709	u32 v;
	710
	711	gzfreeze(&mdec.reg0, sizeof(mdec.reg0));
	712	gzfreeze(&mdec.reg1, sizeof(mdec.reg1));
	713
	714	v = (u8 *)mdec.rl - base;
	715	gzfreeze(&v, sizeof(v));
	716	mdec.rl = (u16 *)(base + (v & 0x1ffffe));
	717	v = (u8 *)mdec.rl_end - base;
	718	gzfreeze(&v, sizeof(v));
	719	mdec.rl_end = (u16 *)(base + (v & 0x1ffffe));
	720
	721	v = 0;
	722	if (mdec.block_buffer_pos)
	723	v = mdec.block_buffer_pos - mdec.block_buffer;
	724	gzfreeze(&v, sizeof(v));
	725	mdec.block_buffer_pos = 0;
	726	if (v && v < sizeof(mdec.block_buffer))
	727	mdec.block_buffer_pos = mdec.block_buffer;
	728
	729	gzfreeze(&mdec.block_buffer, sizeof(mdec.block_buffer));
	730	gzfreeze(&mdec.pending_dma1, sizeof(mdec.pending_dma1));
	731	gzfreeze(iq_y, sizeof(iq_y));
	732	gzfreeze(iq_uv, sizeof(iq_uv));
	733
	734	return 0;
	735	}