libpcsxcore/mdec.c

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