Previous 15994 Revisions Next

r5980 Tuesday 6th October, 2009 at 03:48:05 UTC by Harmony
CD-i video changes: [Harmony, CD-i Fan]
- Added better transparency mode support.
- Added support for DYUV-formatted data.
- Improved CDIC emulation (still not quite right).
[src/mess/drivers]cdi.c

src/mess/drivers/cdi.c
r5979r5980
6464
6565#define ENABLE_UART_PRINTING (0)
6666
67#define VERBOSE_LEVEL   (6)
67#define VERBOSE_LEVEL   (0)
6868
6969INLINE void verboselog(running_machine *machine, int n_level, const char *s_fmt, ...)
7070{
r5979r5980
449449         }
450450         if(ACCESSING_BITS_8_15)
451451         {
452            verboselog(space->machine, 11, "scc68070_periphs_r: Timer Status Register: %02x & %04x\n", scc68070_regs.timers.timer_status_register, mem_mask);
452            verboselog(space->machine, 12, "scc68070_periphs_r: Timer Status Register: %02x & %04x\n", scc68070_regs.timers.timer_status_register, mem_mask);
453453         }
454454         return (scc68070_regs.timers.timer_status_register << 8) | scc68070_regs.timers.timer_control_register;
455455         break;
r5979r5980
710710         }
711711         if(ACCESSING_BITS_8_15)
712712         {
713            verboselog(space->machine, 11, "scc68070_periphs_w: Timer Status Register: %04x & %04x\n", data, mem_mask);
713            verboselog(space->machine, 12, "scc68070_periphs_w: Timer Status Register: %04x & %04x\n", data, mem_mask);
714714            scc68070_regs.timers.timer_status_register &= ~(data >> 8);
715715            if(!scc68070_regs.timers.timer_status_register)
716716            {
r5979r5980
969969
970970         timer_adjust_oneshot(cdic_regs.interrupt_timer, ATTOTIME_IN_HZ(75), 0); // 75Hz = 1x CD-ROM speed
971971
972         cdic_regs.x_buffer |= 0x8000;
972         /* This is wrong, can't figure out right now what's right
973         if(cdic_regs.audio_channel & 0x8000)
974         {
975            cdic_regs.z_buffer |= 0x2000;
976            cdic_regs.audio_buffer |= 0x8000;
977         }
978         else
979         {*/
980            cdic_regs.x_buffer |= 0x8000;
981         //}
973982
974983         cdic_regs.data_buffer |= 0x4000;
975984         cdic_regs.data_buffer &= 0x7fff;
r5979r5980
9991008      }
10001009      case 0x2e: // Abort
10011010         timer_adjust_oneshot(cdic_regs.interrupt_timer, ATTOTIME_IN_HZ(75), 0); // 75Hz = 1x CD-ROM speed
1002         cdic_regs.data_buffer &= 0x7fff;
1011         cdic_regs.data_buffer &= 0x3fff;
10031012         break;
10041013   }
10051014}
r5979r5980
11281137            {
11291138               case 0x23: // Reset Mode 1
11301139               case 0x24: // Reset Mode 2
1131               case 0x2e: // Abort
11321140                  timer_adjust_oneshot(cdic_regs.interrupt_timer, attotime_never, 0);
11331141                  cdic_regs.data_buffer &= 0x3fff;
11341142                  break;
11351143               case 0x29: // Read Mode 1
11361144               case 0x2a: // Read Mode 2
1145               case 0x2e: // Abort
11371146                  timer_adjust_oneshot(cdic_regs.interrupt_timer, ATTOTIME_IN_HZ(75), 0); // 75Hz = 1x CD-ROM speed
11381147                  break;
11391148            }
r5979r5980
14671476
14681477static READ16_HANDLER( m48t08_r )
14691478{
1470   verboselog(space->machine, 6, "m48t08_r: %04x = %02x & %04x\n", offset, m48t08.nvram[offset], mem_mask );
1479   verboselog(space->machine, 11, "m48t08_r: %04x = %02x & %04x\n", offset, m48t08.nvram[offset], mem_mask );
14711480   return m48t08.nvram[offset] << 8;
14721481}
14731482
14741483static WRITE16_HANDLER( m48t08_w )
14751484{
1476   verboselog(space->machine, 6, "m48t08_w: %04x = %02x\n", offset, data >> 8);
1485   verboselog(space->machine, 11, "m48t08_w: %04x = %02x\n", offset, data >> 8);
14771486   switch(offset)
14781487   {
14791488      case 0x1ff9:
r5979r5980
16821691      case 0x10/2:
16831692         if(ACCESSING_BITS_0_7)
16841693         {
1685            verboselog(space->machine, 11, "mcd212_r: Status Register %d: %02x & %04x\n", channel + 1, mcd212.channel[1 - (offset / 8)].csrr, mem_mask);
1694            verboselog(space->machine, 12, "mcd212_r: Status Register %d: %02x & %04x\n", channel + 1, mcd212.channel[1 - (offset / 8)].csrr, mem_mask);
16861695            if(channel == 0)
16871696            {
16881697               return mcd212.channel[0].csrr | 0x20;
r5979r5980
19751984            break;
19761985         case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: // NOP
19771986         case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
1978            verboselog(machine, 11, "%08x: %08x: ICA %d: NOP\n", addr * 2 + channel * 0x200000, cmd, channel );
1987            verboselog(machine, 12, "%08x: %08x: ICA %d: NOP\n", addr * 2 + channel * 0x200000, cmd, channel );
19791988            break;
19801989         case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: // RELOAD DCP
19811990         case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
r5979r5980
20592068            break;
20602069         case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: // NOP
20612070         case 0x18: case 0x19: case 0x1a: case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
2062            verboselog(machine, 11, "%08x: %08x: DCA %d: NOP\n", addr * 2 + channel * 0x200000, cmd, channel );
2071            verboselog(machine, 12, "%08x: %08x: DCA %d: NOP\n", addr * 2 + channel * 0x200000, cmd, channel );
20632072            break;
20642073         case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: // RELOAD DCP
20652074         case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f:
r5979r5980
21202129   }
21212130}
21222131
2132static UINT8 mcd212_dyuv_quantizer[16] = { 0, 1, 4, 9, 16, 27, 44, 79, 128, 177, 212, 229, 240, 247, 252, 255 };
2133
2134INLINE UINT8 MCD212_LIM(INT32 in)
2135{
2136    if(in < 0)
2137    {
2138        return 0;
2139    }
2140    else if(in > 255)
2141    {
2142        return 255;
2143    }
2144    return (UINT8)in;
2145}
2146
21232147static void mcd212_process_vsr(running_machine *machine, int channel, UINT32 *pixels)
21242148{
21252149   UINT8 *data = channel ? (UINT8*)planeb : (UINT8*)planea;
21262150   UINT32 vsr = mcd212_get_vsr(channel) & 0x0007ffff;
21272151   UINT8 done = 0;
21282152   int x = 0;
2153   UINT32 icm_mask = channel ? 0x00000f00 : 0x0000000f;
2154   UINT32 icm_shift = channel ? 8 : 0;
2155   UINT8 icm = (mcd212.channel[0].image_coding_method & icm_mask) >> icm_shift;
21292156
21302157   //printf( "vsr before: %08x: ", vsr );
21312158   //fflush(stdout);
21322159
2133   /*
2134    switch(mcd212.channel[channel].ddr & MCD212_DDR_FT)
2135    {
2136        case MCD212_DDR_FT_BMP:
2137        case MCD212_DDR_FT_BMP2:
2138            if(mcd212.channel[channel].dcr & MCD212_DCR_CM)
2139            {
2140                printf( "4-bit Bitmap: " );
2141            }
2142            else
2143            {
2144                static UINT8 fuck = 0;
2145                printf( "8-bit Bitmap: " );
2146                if(!fuck)
2147                {
2148                    FILE* out = fopen("planea.bin","wb");
2149                    int i = 0;
2150                    for(i = 0; i < 0x80000; i += 2)
2151                    {
2152                        UINT8 temp1, temp2;
2153                        temp1 = planea[i/2] >> 8;
2154                        temp2 = planea[i/2] & 0x00ff;
2155                        fwrite(&temp1, 1, 1, out);
2156                        fwrite(&temp2, 1, 1, out);
2157                    }
2158                    fflush(out);
2159                    fclose(out);
2160                    out = fopen("planeb.bin","wb");
2161                    for(i = 0; i < 0x80000; i += 2)
2162                    {
2163                        UINT8 temp1, temp2;
2164                        temp1 = planeb[i/2] >> 8;
2165                        temp2 = planeb[i/2] & 0x00ff;
2166                        fwrite(&temp1, 1, 1, out);
2167                        fwrite(&temp2, 1, 1, out);
2168                    }
2169                    fflush(out);
2170                    fclose(out);
2171                    fuck++;
2160   if(!icm)
2161   {
2162      for(; x < 768; x++)
2163      {
2164         pixels[x++] = 0x00070707;
2165         pixels[x] = 0x00070707;
2166      }
2167      done = 1;
2168   }
21722169
2173                }
2174            }
2175            break;
2176        case MCD212_DDR_FT_RLE:
2177            if(mcd212.channel[channel].dcr & MCD212_DCR_CM)
2178            {
2179                printf( "4-bit RLE: " );
2180            }
2181            else
2182            {
2183                printf( "8-bit RLE: " );
2184            }
2185            break;
2186        case MCD212_DDR_FT_MOSAIC:
2187            if(mcd212.channel[channel].dcr & MCD212_DCR_CM)
2188            {
2189                printf( "4-bit Mosaic: " );
2190            }
2191            else
2192            {
2193                printf( "8-bit Mosaic: " );
2194            }
2195            break;
2196    }
2197    */
2198
21992170   while(!done)
22002171   {
22012172      UINT8 byte = data[vsr++ ^ 1];
r5979r5980
22132184            else
22142185            {
22152186               // 8-bit Bitmap
2216               for(; x < 768; x++)
2187               UINT32 mask = channel ? 0x00000f00 : 0x0000000f;
2188               UINT32 shift = channel ? 8 : 0;
2189               if(icm == 5)
22172190               {
2218                  pixels[x++] = mcd212.channel[channel].clut[((channel == 1) ? 0x80 : 0x00) + (byte & 0x7f)];
2219                  pixels[x] = mcd212.channel[channel].clut[((channel == 1) ? 0x80 : 0x00) + (byte & 0x7f)];
2220                  byte = data[vsr++ ^ 1];
2191                  UINT8 y;
2192                  INT16 u;
2193                  INT16 v;
2194                  switch(channel)
2195                  {
2196                     case 0:
2197                        y = (mcd212.channel[0].dyuv_abs_start_a >> 16) & 0x000000ff;
2198                        u = (mcd212.channel[0].dyuv_abs_start_a >>  8) & 0x000000ff;
2199                        v = (mcd212.channel[0].dyuv_abs_start_a >>  0) & 0x000000ff;
2200                        break;
2201                     case 1:
2202                        y = (mcd212.channel[1].dyuv_abs_start_b >> 16) & 0x000000ff;
2203                        u = (mcd212.channel[1].dyuv_abs_start_b >>  8) & 0x000000ff;
2204                        v = (mcd212.channel[1].dyuv_abs_start_b >>  0) & 0x000000ff;
2205                        break;
2206                     default:
2207                        y = u = v = 0x80;
2208                        break;
2209                  }
2210                  for(; x < 768;)
2211                  {
2212                     UINT8 r, g, b;
2213                     UINT16 curr = (byte << 8) | data[vsr++ ^ 1];
2214                     UINT16 next = (x < 766) ? ((data[(vsr + 1) ^ 1] << 8) | data[(vsr + 2) ^ 1]) : curr;
2215                     UINT8 y0 = (INT8)mcd212_dyuv_quantizer[(curr >>  8) & 0x000f];
2216                     INT16 u0 = (INT8)mcd212_dyuv_quantizer[(curr >> 12) & 0x000f];
2217                     INT16 v0 = (INT8)mcd212_dyuv_quantizer[(curr >>  4) & 0x000f];
2218                     UINT8 y1 = (INT8)mcd212_dyuv_quantizer[(curr >>  0) & 0x000f];
2219                     INT16 ut = (INT8)mcd212_dyuv_quantizer[(next >> 12) & 0x000f];
2220                     INT16 vt = (INT8)mcd212_dyuv_quantizer[(next >>  4) & 0x000f];
2221                     INT16 u1 = (u0 + ut) / 2;
2222                     INT16 v1 = (v0 + vt) / 2;
2223                     u += u0;
2224                     v += v0;
2225                     y += y0;
2226                        r = MCD212_LIM( ((y << 8) + 351 * (v - 128)) >> 8 );
2227                        g = MCD212_LIM( ((y << 8) + (86 * (u - 128) + 179 * (v - 128))) >> 8 );
2228                        b = MCD212_LIM( ((y << 8) + 444 * (u - 128)) >> 8 );
2229                        pixels[x++] = (r << 16) | (g << 8) | b;
2230                        pixels[x++] = (r << 16) | (g << 8) | b;
2231                     u += u1;
2232                     v += v1;
2233                     y += y1;
2234                        r = MCD212_LIM( ((y << 8) + 351 * (v - 128)) >> 8 );
2235                        g = MCD212_LIM( ((y << 8) + (86 * (u - 128) + 179 * (v - 128))) >> 8 );
2236                        b = MCD212_LIM( ((y << 8) + 444 * (u - 128)) >> 8 );
2237                        pixels[x++] = (r << 16) | (g << 8) | b;
2238                        pixels[x++] = (r << 16) | (g << 8) | b;
2239                     byte = data[vsr++ ^ 1];
2240                  }
2241                  mcd212_set_vsr(channel, vsr - 1);
22212242               }
2222               mcd212_set_vsr(channel, vsr - 1);
2243               else if(((mcd212.channel[0].image_coding_method & mask) >> shift) == 0x3)
2244               {
2245                  for(; x < 768; x++)
2246                  {
2247                     pixels[x++] = mcd212.channel[channel].clut[((channel == 1) ? 0x80 : 0x00) + (byte & 0x7f)];
2248                     pixels[x] = mcd212.channel[channel].clut[((channel == 1) ? 0x80 : 0x00) + (byte & 0x7f)];
2249                     byte = data[vsr++ ^ 1];
2250                  }
2251                  mcd212_set_vsr(channel, vsr - 1);
2252               }
2253               else
2254               {
2255                  for(; x < 768; x++)
2256                  {
2257                     pixels[x++] = 0x00070707;
2258                     pixels[x] = 0x00070707;
2259                  }
2260               }
22232261            }
22242262            done = 1;
22252263            break;
r5979r5980
22922330   //mcd212_set_vsr(channel, vsr);
22932331}
22942332
2333static const UINT32 mcd212_4bpp_color[16] =
2334{
2335   0x00000000, 0x0000007f, 0x00007f00, 0x00007f7f, 0x007f0000, 0x007f007f, 0x007f7f00, 0x007f7f7f,
2336   0x00000000, 0x000000ff, 0x0000ff00, 0x0000ffff, 0x00ff0000, 0x00ff00ff, 0x00ffff00, 0x00ffffff
2337};
2338
22952339static void mcd212_draw_cursor(running_machine *machine, UINT32 *scanline, int y)
22962340{
22972341   if(mcd212.channel[0].cursor_control & MCD212_CURCNT_EN)
r5979r5980
23022346      cury += 22;
23032347      if(y >= cury && y < (cury + 16))
23042348      {
2305         UINT32 color = 0;
2306         switch(mcd212.channel[0].cursor_control & MCD212_CURCNT_COLOR)
2307         {
2308            case 0x01:
2309               color = 0x0000007f;
2310               break;
2311            case 0x02:
2312               color = 0x00007f00;
2313               break;
2314            case 0x03:
2315               color = 0x00007f7f;
2316               break;
2317            case 0x04:
2318               color = 0x007f0000;
2319               break;
2320            case 0x05:
2321               color = 0x007f007f;
2322               break;
2323            case 0x06:
2324               color = 0x007f7f00;
2325               break;
2326            case 0x07:
2327               color = 0x007f7f7f;
2328               break;
2329            case 0x09:
2330               color = 0x000000ff;
2331               break;
2332            case 0x0a:
2333               color = 0x0000ff00;
2334               break;
2335            case 0x0b:
2336               color = 0x0000ffff;
2337               break;
2338            case 0x0c:
2339               color = 0x00ff0000;
2340               break;
2341            case 0x0d:
2342               color = 0x00ff00ff;
2343               break;
2344            case 0x0e:
2345               color = 0x00ffff00;
2346               break;
2347            case 0x0f:
2348               color = 0x00ffffff;
2349               break;
2350         }
2349         UINT32 color = mcd212_4bpp_color[mcd212.channel[0].cursor_control & MCD212_CURCNT_COLOR];
23512350         y -= cury;
23522351         for(x = curx; x < curx + 16; x++)
23532352         {
r5979r5980
23662365static void mcd212_mix_lines(running_machine *machine, UINT32 *plane_a, UINT32 *plane_b, UINT32 *out)
23672366{
23682367   int x = 0;
2369   UINT32 backdrop = 0;
2370   if(mcd212.channel[0].transparency_control != 0x800101)
2371   {
2372      verboselog(machine, 11, "Unhandled transparency control value for mixing, %08x, visual results may not be accurate\n", mcd212.channel[0].transparency_control);
2373   }
2374   switch(mcd212.channel[0].backdrop_color)
2375   {
2376      case 0x01:
2377         backdrop = 0x0000007f;
2378         break;
2379      case 0x02:
2380         backdrop = 0x00007f00;
2381         break;
2382      case 0x03:
2383         backdrop = 0x00007f7f;
2384         break;
2385      case 0x04:
2386         backdrop = 0x007f0000;
2387         break;
2388      case 0x05:
2389         backdrop = 0x007f007f;
2390         break;
2391      case 0x06:
2392         backdrop = 0x007f7f00;
2393         break;
2394      case 0x07:
2395         backdrop = 0x007f7f7f;
2396         break;
2397      case 0x09:
2398         backdrop = 0x000000ff;
2399         break;
2400      case 0x0a:
2401         backdrop = 0x0000ff00;
2402         break;
2403      case 0x0b:
2404         backdrop = 0x0000ffff;
2405         break;
2406      case 0x0c:
2407         backdrop = 0x00ff0000;
2408         break;
2409      case 0x0d:
2410         backdrop = 0x00ff00ff;
2411         break;
2412      case 0x0e:
2413         backdrop = 0x00ffff00;
2414         break;
2415      case 0x0f:
2416         backdrop = 0x00ffffff;
2417         break;
2418   }
2368   UINT32 backdrop = mcd212_4bpp_color[mcd212.channel[0].backdrop_color];
24192369   for(x = 0; x < 768; x++)
24202370   {
24212371      out[x] = backdrop;
2422      switch(mcd212.channel[0].plane_order)
2372      if(!(mcd212.channel[0].transparency_control & MCD212_TCR_DISABLE_MX))
24232373      {
2424         case MCD212_POR_AB:
2425            if(plane_a[x] != mcd212.channel[0].transparent_color_a)
2374         INT32 weight_a = mcd212.channel[0].weight_factor_a;
2375         INT32 weight_b = mcd212.channel[1].weight_factor_b;
2376         INT32 ar = (plane_a[x] >> 16) & 0x000000ff;
2377         INT32 ag = (plane_a[x] >>  8) & 0x000000ff;
2378         INT32 ab = (plane_a[x] >>  0) & 0x000000ff;
2379         INT32 br = (plane_b[x] >> 16) & 0x000000ff;
2380         INT32 bg = (plane_b[x] >>  8) & 0x000000ff;
2381         INT32 bb = (plane_b[x] >>  0) & 0x000000ff;
2382         UINT8 abr = MCD212_LIM((MCD212_LIM(ar - 16) * weight_a) / 64 + (MCD212_LIM(br - 16) * weight_b) / 64 + 16);
2383         UINT8 abg = MCD212_LIM((MCD212_LIM(ag - 16) * weight_a) / 64 + (MCD212_LIM(bg - 16) * weight_b) / 64 + 16);
2384         UINT8 abb = MCD212_LIM((MCD212_LIM(ab - 16) * weight_a) / 64 + (MCD212_LIM(bb - 16) * weight_b) / 64 + 16);
2385         out[x] = (abr << 16) | (abg << 8) | abb;
2386      }
2387      else
2388      {
2389         UINT8 transparency_mode[2] =
2390         {
2391            (mcd212.channel[0].transparency_control >> 0) & 0x0f,
2392            (mcd212.channel[0].transparency_control >> 8) & 0x0f
2393         };
2394         UINT8 plane_enable[2] =
2395         {
2396            0,
2397            0
2398         };
2399         int index = 0;
2400         for(index = 0; index < 2; index++)
2401         {
2402            UINT32 *plane = index ? plane_b : plane_a;
2403            UINT32 transparent_color = index ? mcd212.channel[1].transparent_color_b : mcd212.channel[0].transparent_color_a;
2404            switch(transparency_mode[index])
24262405            {
2427               out[x] = plane_a[x];
2406               case 0:
2407                  plane_enable[index] = 0;
2408                  break;
2409               case 1:
2410                  if(plane[x] != transparent_color)
2411                  {
2412                     plane_enable[index] = 1;
2413                  }
2414                  break;
2415               case 8:
2416                  plane_enable[index] = 1;
2417                  break;
2418               case 9:
2419                  if(plane[x] == transparent_color)
2420                  {
2421                     plane_enable[index] = 1;
2422                  }
2423                  break;
2424               default:
2425                  verboselog(machine, 0, "Unhandled transparency mode for plane %c: %d\n", index ? 'B' : 'A', transparency_mode[index]);
2426                  break;
24282427            }
2429            else if(plane_b[x] != mcd212.channel[1].transparent_color_b)
2430            {
2431               out[x] = plane_b[x];
2432            }
2433            else
2434            break;
2435         case MCD212_POR_BA:
2436            if(plane_b[x] != mcd212.channel[1].transparent_color_b)
2437            {
2438               out[x] = plane_b[x];
2439            }
2440            else if(plane_a[x] != mcd212.channel[0].transparent_color_a)
2441            {
2442               out[x] = plane_a[x];
2443            }
2444            break;
2428         }
2429         switch(mcd212.channel[0].plane_order)
2430         {
2431            case MCD212_POR_AB:
2432               if(plane_enable[0])
2433               {
2434                  out[x] = plane_a[x];
2435               }
2436               else if(plane_enable[1])
2437               {
2438                  out[x] = plane_b[x];
2439               }
2440               break;
2441            case MCD212_POR_BA:
2442               if(plane_enable[1])
2443               {
2444                  out[x] = plane_b[x];
2445               }
2446               else if(plane_enable[0])
2447               {
2448                  out[x] = plane_a[x];
2449               }
2450               break;
2451         }
24452452      }
24462453   }
24472454}

Previous 15994 Revisions Next


© 1998-2018 The MESS Team