src/mess/drivers/cdi.c
| r5979 | r5980 | |
| 64 | 64 | |
| 65 | 65 | #define ENABLE_UART_PRINTING (0) |
| 66 | 66 | |
| 67 | | #define VERBOSE_LEVEL (6) |
| 67 | #define VERBOSE_LEVEL (0) |
| 68 | 68 | |
| 69 | 69 | INLINE void verboselog(running_machine *machine, int n_level, const char *s_fmt, ...) |
| 70 | 70 | { |
| r5979 | r5980 | |
| 449 | 449 | } |
| 450 | 450 | if(ACCESSING_BITS_8_15) |
| 451 | 451 | { |
| 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); |
| 453 | 453 | } |
| 454 | 454 | return (scc68070_regs.timers.timer_status_register << 8) | scc68070_regs.timers.timer_control_register; |
| 455 | 455 | break; |
| r5979 | r5980 | |
| 710 | 710 | } |
| 711 | 711 | if(ACCESSING_BITS_8_15) |
| 712 | 712 | { |
| 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); |
| 714 | 714 | scc68070_regs.timers.timer_status_register &= ~(data >> 8); |
| 715 | 715 | if(!scc68070_regs.timers.timer_status_register) |
| 716 | 716 | { |
| r5979 | r5980 | |
| 969 | 969 | |
| 970 | 970 | timer_adjust_oneshot(cdic_regs.interrupt_timer, ATTOTIME_IN_HZ(75), 0); // 75Hz = 1x CD-ROM speed |
| 971 | 971 | |
| 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 | //} |
| 973 | 982 | |
| 974 | 983 | cdic_regs.data_buffer |= 0x4000; |
| 975 | 984 | cdic_regs.data_buffer &= 0x7fff; |
| r5979 | r5980 | |
| 999 | 1008 | } |
| 1000 | 1009 | case 0x2e: // Abort |
| 1001 | 1010 | 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; |
| 1003 | 1012 | break; |
| 1004 | 1013 | } |
| 1005 | 1014 | } |
| r5979 | r5980 | |
| 1128 | 1137 | { |
| 1129 | 1138 | case 0x23: // Reset Mode 1 |
| 1130 | 1139 | case 0x24: // Reset Mode 2 |
| 1131 | | case 0x2e: // Abort |
| 1132 | 1140 | timer_adjust_oneshot(cdic_regs.interrupt_timer, attotime_never, 0); |
| 1133 | 1141 | cdic_regs.data_buffer &= 0x3fff; |
| 1134 | 1142 | break; |
| 1135 | 1143 | case 0x29: // Read Mode 1 |
| 1136 | 1144 | case 0x2a: // Read Mode 2 |
| 1145 | case 0x2e: // Abort |
| 1137 | 1146 | timer_adjust_oneshot(cdic_regs.interrupt_timer, ATTOTIME_IN_HZ(75), 0); // 75Hz = 1x CD-ROM speed |
| 1138 | 1147 | break; |
| 1139 | 1148 | } |
| r5979 | r5980 | |
| 1467 | 1476 | |
| 1468 | 1477 | static READ16_HANDLER( m48t08_r ) |
| 1469 | 1478 | { |
| 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 ); |
| 1471 | 1480 | return m48t08.nvram[offset] << 8; |
| 1472 | 1481 | } |
| 1473 | 1482 | |
| 1474 | 1483 | static WRITE16_HANDLER( m48t08_w ) |
| 1475 | 1484 | { |
| 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); |
| 1477 | 1486 | switch(offset) |
| 1478 | 1487 | { |
| 1479 | 1488 | case 0x1ff9: |
| r5979 | r5980 | |
| 1682 | 1691 | case 0x10/2: |
| 1683 | 1692 | if(ACCESSING_BITS_0_7) |
| 1684 | 1693 | { |
| 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); |
| 1686 | 1695 | if(channel == 0) |
| 1687 | 1696 | { |
| 1688 | 1697 | return mcd212.channel[0].csrr | 0x20; |
| r5979 | r5980 | |
| 1975 | 1984 | break; |
| 1976 | 1985 | case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: // NOP |
| 1977 | 1986 | 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 ); |
| 1979 | 1988 | break; |
| 1980 | 1989 | case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: // RELOAD DCP |
| 1981 | 1990 | case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f: |
| r5979 | r5980 | |
| 2059 | 2068 | break; |
| 2060 | 2069 | case 0x10: case 0x11: case 0x12: case 0x13: case 0x14: case 0x15: case 0x16: case 0x17: // NOP |
| 2061 | 2070 | 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 ); |
| 2063 | 2072 | break; |
| 2064 | 2073 | case 0x20: case 0x21: case 0x22: case 0x23: case 0x24: case 0x25: case 0x26: case 0x27: // RELOAD DCP |
| 2065 | 2074 | case 0x28: case 0x29: case 0x2a: case 0x2b: case 0x2c: case 0x2d: case 0x2e: case 0x2f: |
| r5979 | r5980 | |
| 2120 | 2129 | } |
| 2121 | 2130 | } |
| 2122 | 2131 | |
| 2132 | static UINT8 mcd212_dyuv_quantizer[16] = { 0, 1, 4, 9, 16, 27, 44, 79, 128, 177, 212, 229, 240, 247, 252, 255 }; |
| 2133 | |
| 2134 | INLINE 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 | |
| 2123 | 2147 | static void mcd212_process_vsr(running_machine *machine, int channel, UINT32 *pixels) |
| 2124 | 2148 | { |
| 2125 | 2149 | UINT8 *data = channel ? (UINT8*)planeb : (UINT8*)planea; |
| 2126 | 2150 | UINT32 vsr = mcd212_get_vsr(channel) & 0x0007ffff; |
| 2127 | 2151 | UINT8 done = 0; |
| 2128 | 2152 | 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; |
| 2129 | 2156 | |
| 2130 | 2157 | //printf( "vsr before: %08x: ", vsr ); |
| 2131 | 2158 | //fflush(stdout); |
| 2132 | 2159 | |
| 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 | } |
| 2172 | 2169 | |
| 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 | | |
| 2199 | 2170 | while(!done) |
| 2200 | 2171 | { |
| 2201 | 2172 | UINT8 byte = data[vsr++ ^ 1]; |
| r5979 | r5980 | |
| 2213 | 2184 | else |
| 2214 | 2185 | { |
| 2215 | 2186 | // 8-bit Bitmap |
| 2216 | | for(; x < 768; x++) |
| 2187 | UINT32 mask = channel ? 0x00000f00 : 0x0000000f; |
| 2188 | UINT32 shift = channel ? 8 : 0; |
| 2189 | if(icm == 5) |
| 2217 | 2190 | { |
| 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); |
| 2221 | 2242 | } |
| 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 | } |
| 2223 | 2261 | } |
| 2224 | 2262 | done = 1; |
| 2225 | 2263 | break; |
| r5979 | r5980 | |
| 2292 | 2330 | //mcd212_set_vsr(channel, vsr); |
| 2293 | 2331 | } |
| 2294 | 2332 | |
| 2333 | static 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 | |
| 2295 | 2339 | static void mcd212_draw_cursor(running_machine *machine, UINT32 *scanline, int y) |
| 2296 | 2340 | { |
| 2297 | 2341 | if(mcd212.channel[0].cursor_control & MCD212_CURCNT_EN) |
| r5979 | r5980 | |
| 2302 | 2346 | cury += 22; |
| 2303 | 2347 | if(y >= cury && y < (cury + 16)) |
| 2304 | 2348 | { |
| 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]; |
| 2351 | 2350 | y -= cury; |
| 2352 | 2351 | for(x = curx; x < curx + 16; x++) |
| 2353 | 2352 | { |
| r5979 | r5980 | |
| 2366 | 2365 | static void mcd212_mix_lines(running_machine *machine, UINT32 *plane_a, UINT32 *plane_b, UINT32 *out) |
| 2367 | 2366 | { |
| 2368 | 2367 | 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]; |
| 2419 | 2369 | for(x = 0; x < 768; x++) |
| 2420 | 2370 | { |
| 2421 | 2371 | out[x] = backdrop; |
| 2422 | | switch(mcd212.channel[0].plane_order) |
| 2372 | if(!(mcd212.channel[0].transparency_control & MCD212_TCR_DISABLE_MX)) |
| 2423 | 2373 | { |
| 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]) |
| 2426 | 2405 | { |
| 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; |
| 2428 | 2427 | } |
| 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 | } |
| 2445 | 2452 | } |
| 2446 | 2453 | } |
| 2447 | 2454 | } |