| Previous | 15994 Revisions | Next |
| r6080 Wednesday 14th October, 2009 at 21:03:35 UTC by Harmony |
|---|
| [CDI] Significant optimization: - Removed redudant call to mcd212_process_regions - Refactored mcd212_process_regions to fill scanline-wide buffers for region flags and pixel weights, eliminating costly recalculation for every pixel - Refactored color calculations to use separated R/G/B buffers to avoid constant bit-shifting / boolean arithmetic - Un-inlined certain functions to possibly improve cache performance with better code locality - Unrolled plane enable/disable logic to avoid frequent array lookups Performance has increased on a 1.86GHz Core 2 Duo from 28% in a profile build to 75% profile build, flat 100% on a non-profile build |
| [src/mess/drivers] | cdi.c |
| r6079 | r6080 | |
|---|---|---|
| 91 | 91 | static WRITE16_HANDLER( m48t08_w ); |
| 92 | 92 | |
| 93 | 93 | // Platform-specific |
| 94 | ||
| 94 | static void cdi220_draw_lcd(running_machine *machine, int y); | |
| 95 | 95 | |
| 96 | 96 | // MCD212 |
| 97 | 97 | static READ16_HANDLER(mcd212_r); |
| 98 | 98 | static WRITE16_HANDLER(mcd212_w); |
| 99 | INLINE void mcd212_set_register(running_machine *machine, int channel, UINT8 reg, UINT32 value); | |
| 100 | INLINE void mcd212_set_vsr(int channel, UINT32 value); | |
| 101 | INLINE UINT32 mcd212_get_vsr(int channel); | |
| 102 | INLINE void mcd212_set_dcp(int channel, UINT32 value); | |
| 103 | INLINE UINT32 mcd212_get_dcp(int channel); | |
| 104 | INLINE void mcd212_set_display_parameters(int channel, UINT8 value); | |
| 105 | INLINE void mcd212_process_ica(running_machine *machine, int channel); | |
| 106 | INLINE void mcd212_process_dca(running_machine *machine, int channel); | |
| 107 | INLINE void mcd212_process_vsr(running_machine *machine, int channel, UINT32 *pixels); | |
| 108 | INLINE void mcd212_draw_cursor(running_machine *machine, UINT32 *scanline, int y); | |
| 109 | INLINE void mcd212_mix_lines(running_machine *machine, UINT32 *plane_a, UINT32 *plane_b, UINT32 *out); | |
| 99 | static void mcd212_set_register(running_machine *machine, int channel, UINT8 reg, UINT32 value); | |
| 100 | static void mcd212_set_vsr(int channel, UINT32 value); | |
| 101 | static UINT32 mcd212_get_vsr(int channel); | |
| 102 | static void mcd212_set_dcp(int channel, UINT32 value); | |
| 103 | static UINT32 mcd212_get_dcp(int channel); | |
| 104 | static void mcd212_set_display_parameters(int channel, UINT8 value); | |
| 105 | static void mcd212_process_ica(running_machine *machine, int channel); | |
| 106 | static void mcd212_process_dca(running_machine *machine, int channel); | |
| 107 | static void mcd212_update_region_arrays(running_machine *machine); | |
| 108 | static void mcd212_process_vsr(running_machine *machine, int channel, UINT8 *pixels_r, UINT8 *pixels_g, UINT8 *pixels_b); | |
| 109 | static void mcd212_draw_cursor(running_machine *machine, UINT32 *scanline, int y); | |
| 110 | static void mcd212_mix_lines(running_machine *machine, UINT8 *plane_a_r, UINT8 *plane_a_g, UINT8 *plane_a_b, UINT8 *plane_b_r, UINT8 *plane_b_g, UINT8 *plane_b_b, UINT32 *out); | |
| 110 | 111 | static void mcd212_draw_scanline(running_machine *machine, int y); |
| 111 | 112 | TIMER_CALLBACK( mcd212_perform_scan ); |
| 112 | 113 | static VIDEO_START(cdi); |
| r6079 | r6080 | |
| 906 | 907 | cdrom_file *cd; |
| 907 | 908 | } cdic_regs_t; |
| 908 | 909 | |
| 910 | #define CDIC_SECTOR_SYNC 0 | |
| 911 | ||
| 912 | #define CDIC_SECTOR_HEADER 12 | |
| 913 | ||
| 914 | #define CDIC_SECTOR_MODE 15 | |
| 915 | ||
| 916 | #define CDIC_SECTOR_FILE1 16 | |
| 917 | #define CDIC_SECTOR_CHAN1 17 | |
| 918 | #define CDIC_SECTOR_SUBMODE1 18 | |
| 919 | #define CDIC_SECTOR_CODING1 19 | |
| 920 | ||
| 921 | #define CDIC_SECTOR_FILE2 20 | |
| 922 | #define CDIC_SECTOR_CHAN2 21 | |
| 923 | #define CDIC_SECTOR_SUBMODE2 22 | |
| 924 | #define CDIC_SECTOR_CODING2 23 | |
| 925 | ||
| 926 | #define CDIC_SECTOR_DATA 24 | |
| 927 | ||
| 928 | #define CDIC_SECTOR_SIZE 2352 | |
| 929 | ||
| 930 | #define CDIC_SECTOR_DATASIZE 2048 | |
| 931 | #define CDIC_SECTOR_AUDIOSIZE 2304 | |
| 932 | #define CDIC_SECTOR_VIDEOSIZE 2324 | |
| 933 | ||
| 934 | #define CDIC_SUBMODE_EOF 0x80 | |
| 935 | #define CDIC_SUBMODE_RT 0x40 | |
| 936 | #define CDIC_SUBMODE_FORM 0x20 | |
| 937 | #define CDIC_SUBMODE_TRIG 0x10 | |
| 938 | #define CDIC_SUBMODE_DATA 0x08 | |
| 939 | #define CDIC_SUBMODE_AUDIO 0x04 | |
| 940 | #define CDIC_SUBMODE_VIDEO 0x02 | |
| 941 | #define CDIC_SUBMODE_EOR 0x01 | |
| 942 | ||
| 909 | 943 | static cdic_regs_t cdic_regs; |
| 910 | 944 | |
| 911 | 945 | static TIMER_CALLBACK( cdic_trigger_readback_int ) |
| r6079 | r6080 | |
| 939 | 973 | //printf( "Reading Mode %d sector from MSF location %06x\n", cdic_regs.command - 0x28, cdic_regs.time | 2 ); |
| 940 | 974 | verboselog(machine, 0, "Reading Mode %d sector from MSF location %06x\n", cdic_regs.command - 0x28, cdic_regs.time | 2 ); |
| 941 | 975 | |
| 976 | cdic_regs.z_buffer ^= 0x0001; | |
| 942 | 977 | cdic_regs.data_buffer ^= 0x0001; |
| 943 | 978 | |
| 944 | 979 | cdrom_read_data(cdic_regs.cd, lba, buffer, CD_TRACK_RAW_DONTCARE); |
| r6079 | r6080 | |
| 974 | 1009 | } |
| 975 | 1010 | } |
| 976 | 1011 | |
| 977 | if(((buffer[22] & 0x2e) == 0x24) && (cdic_regs.channel & cdic_regs.audio_channel & (1 << buffer[21]))) | |
| 1012 | if(((buffer[CDIC_SECTOR_SUBMODE2] & (CDIC_SUBMODE_FORM | CDIC_SUBMODE_DATA | CDIC_SUBMODE_AUDIO | CDIC_SUBMODE_VIDEO)) == (CDIC_SUBMODE_FORM | CDIC_SUBMODE_AUDIO)) && | |
| 1013 | (cdic_regs.channel & cdic_regs.audio_channel & (1 << buffer[CDIC_SECTOR_CHAN2]))) | |
| 978 | 1014 | { |
| 979 | 1015 | // Ignore the audio sector for now. |
| 980 | if(!(buffer[22] & 0x10)) | |
| 981 | { | |
| 982 | verboselog(machine, 0, "Audio sector, ignored\n" ); | |
| 983 | } | |
| 984 | else | |
| 985 | { | |
| 986 | cdic_regs.x_buffer |= 0x8000; | |
| 1016 | cdic_regs.x_buffer |= 0x8000; | |
| 987 | 1017 | |
| 988 | cdic_regs.data_buffer |= 0x4000; | |
| 989 | cdic_regs.data_buffer &= 0x7fff; | |
| 1018 | cdic_regs.data_buffer |= 0x4000; | |
| 1019 | cdic_regs.data_buffer &= 0x7fff; | |
| 990 | 1020 | |
| 991 | //printf( "Setting CDIC interrupt line\n" ); | |
| 992 | verboselog(machine, 0, "Setting CDIC interrupt line\n" ); | |
| 993 | cpu_set_input_line_vector(cputag_get_cpu(machine, "maincpu"), M68K_IRQ_4, 128); | |
| 994 | cputag_set_input_line(machine, "maincpu", M68K_IRQ_4, ASSERT_LINE); | |
| 995 | } | |
| 1021 | //printf( "Setting CDIC interrupt line\n" ); | |
| 1022 | verboselog(machine, 0, "Setting CDIC interrupt line\n" ); | |
| 1023 | cpu_set_input_line_vector(cputag_get_cpu(machine, "maincpu"), M68K_IRQ_4, 128); | |
| 1024 | cputag_set_input_line(machine, "maincpu", M68K_IRQ_4, ASSERT_LINE); | |
| 996 | 1025 | } |
| 997 | else if((buffer[2 | |
| 1026 | else if((buffer[CDIC_SECTOR_SUBMODE2 | |
| 998 | 1027 | { |
| 999 | 1028 | // Ignore the audio sector for now. |
| 1000 | if(!(buffer[2 | |
| 1029 | if(!(buffer[CDIC_SECTOR_SUBMODE2 | |
| 1001 | 1030 | { |
| 1002 | 1031 | verboselog(machine, 0, "Message sector, ignored\n" ); |
| 1003 | 1032 | } |
| r6079 | r6080 | |
| 1014 | 1043 | cputag_set_input_line(machine, "maincpu", M68K_IRQ_4, ASSERT_LINE); |
| 1015 | 1044 | } |
| 1016 | 1045 | } |
| 1017 | else | |
| 1046 | else | |
| 1018 | 1047 | { |
| 1019 | 1048 | cdic_regs.x_buffer |= 0x8000; |
| 1020 | 1049 | |
| r6079 | r6080 | |
| 1027 | 1056 | cputag_set_input_line(machine, "maincpu", M68K_IRQ_4, ASSERT_LINE); |
| 1028 | 1057 | } |
| 1029 | 1058 | |
| 1030 | timer_adjust_oneshot(cdic_regs.interrupt_timer, ATTOTIME_IN_HZ(75), 0); // 75Hz = 1x CD-ROM speed | |
| 1059 | if(!(buffer[CDIC_SECTOR_SUBMODE2] & CDIC_SUBMODE_EOF)) | |
| 1060 | { | |
| 1061 | timer_adjust_oneshot(cdic_regs.interrupt_timer, ATTOTIME_IN_HZ(75), 0); // 75Hz = 1x CD-ROM speed | |
| 1062 | } | |
| 1031 | 1063 | |
| 1032 | 1064 | break; |
| 1033 | 1065 | } |
| r6079 | r6080 | |
| 1320 | 1352 | { |
| 1321 | 1353 | UINT16 x, y; |
| 1322 | 1354 | |
| 1323 | printf( "Set mouse position: %02x %02x %02x\n", slave_regs.in_buf[0], slave_regs.in_buf[1], slave_regs.in_buf[2] ); | |
| 1355 | //printf( "Set mouse position: %02x %02x %02x\n", slave_regs.in_buf[0], slave_regs.in_buf[1], slave_regs.in_buf[2] ); | |
| 1324 | 1356 | |
| 1325 | 1357 | slave_regs.fake_mouse_y = ((slave_regs.in_buf[1] & 0x0f) << 6) | (slave_regs.in_buf[0] & 0x3f); |
| 1326 | 1358 | slave_regs.fake_mouse_x = ((slave_regs.in_buf[1] & 0x70) << 3) | slave_regs.in_buf[2]; |
| r6079 | r6080 | |
| 1627 | 1659 | UINT16 ddr; |
| 1628 | 1660 | UINT16 dcp; |
| 1629 | 1661 | UINT32 dca; |
| 1630 | UINT32 clut[256]; | |
| 1662 | UINT8 clut_r[256]; | |
| 1663 | UINT8 clut_g[256]; | |
| 1664 | UINT8 clut_b[256]; | |
| 1631 | 1665 | UINT32 image_coding_method; |
| 1632 | 1666 | UINT32 transparency_control; |
| 1633 | 1667 | UINT32 plane_order; |
| r6079 | r6080 | |
| 1648 | 1682 | UINT32 backdrop_color; |
| 1649 | 1683 | UINT32 mosaic_hold_a; |
| 1650 | 1684 | UINT32 mosaic_hold_b; |
| 1651 | UINT32 weight_factor_a; | |
| 1652 | UINT32 weight_factor_b; | |
| 1685 | UINT8 weight_factor_a[768]; | |
| 1686 | UINT8 weight_factor_b[768]; | |
| 1653 | 1687 | } mcd212_channel_t; |
| 1654 | 1688 | |
| 1655 | 1689 | typedef struct |
| 1656 | 1690 | { |
| 1657 | 1691 | mcd212_channel_t channel[2]; |
| 1658 | 1692 | emu_timer *scan_timer; |
| 1659 | UINT8 region_flag[2]; | |
| 1693 | UINT8 region_flag_0[768]; | |
| 1694 | UINT8 region_flag_1[768]; | |
| 1660 | 1695 | } mcd212_t; |
| 1661 | 1696 | |
| 1662 | 1697 | mcd212_t mcd212; |
| r6079 | r6080 | |
| 1754 | 1789 | 0x1000, 0x1000, 0x1000, 0x1000, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0400, 0x0400, 0x0400, 0x0400 |
| 1755 | 1790 | }; |
| 1756 | 1791 | |
| 1757 | ||
| 1792 | static void cdi220_draw_lcd(running_machine *machine, int y) | |
| 1758 | 1793 | { |
| 1759 | 1794 | bitmap_t *bitmap = tmpbitmap; |
| 1760 | 1795 | UINT32 *scanline = BITMAP_ADDR32(bitmap, y, 0); |
| r6079 | r6080 | |
| 1876 | 1911 | } |
| 1877 | 1912 | } |
| 1878 | 1913 | |
| 1879 | ||
| 1914 | static void mcd212_set_register(running_machine *machine, int channel, UINT8 reg, UINT32 value) | |
| 1880 | 1915 | { |
| 1881 | 1916 | switch(reg) |
| 1882 | 1917 | { |
| r6079 | r6080 | |
| 1888 | 1923 | case 0xa8: case 0xa9: case 0xaa: case 0xab: case 0xac: case 0xad: case 0xae: case 0xaf: |
| 1889 | 1924 | case 0xb0: case 0xb1: case 0xb2: case 0xb3: case 0xb4: case 0xb5: case 0xb6: case 0xb7: |
| 1890 | 1925 | case 0xb8: case 0xb9: case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe: case 0xbf: |
| 1891 | verboselog(machine, 6, " %04xxxxx: %d: CLUT[%d] = %08x\n", channel * 0x20, channel, mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80), value ); | |
| 1892 | mcd212.channel[0].clut[mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = value; | |
| 1926 | verboselog(machine, 11, " %04xxxxx: %d: CLUT[%d] = %08x\n", channel * 0x20, channel, mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80), value ); | |
| 1927 | mcd212.channel[0].clut_r[mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 16); | |
| 1928 | mcd212.channel[0].clut_g[mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 8); | |
| 1929 | mcd212.channel[0].clut_b[mcd212.channel[channel].clut_bank * 0x40 + (reg - 0x80)] = (UINT8)(value >> 0); | |
| 1893 | 1930 | break; |
| 1894 | 1931 | case 0xc0: // Image Coding Method |
| 1895 | 1932 | if(channel == 0) |
| r6079 | r6080 | |
| 1989 | 2026 | case 0xd7: |
| 1990 | 2027 | verboselog(machine, 6, " %04xxxxx: %d: Region Control %d = %08x\n", channel * 0x20, channel, reg & 7, value ); |
| 1991 | 2028 | mcd212.channel[0].region_control[reg & 7] = value; |
| 2029 | mcd212_update_region_arrays(machine); | |
| 1992 | 2030 | break; |
| 1993 | 2031 | case 0xd8: // Backdrop Color |
| 1994 | 2032 | if(channel == 0) |
| r6079 | r6080 | |
| 2015 | 2053 | if(channel == 0) |
| 2016 | 2054 | { |
| 2017 | 2055 | verboselog(machine, 6, " %04xxxxx: %d: Weight Factor A = %08x\n", channel * 0x20, channel, value ); |
| 2018 | mcd212.channel[channel].weight_factor_a = value; | |
| 2056 | memset(mcd212.channel[channel].weight_factor_a, value & 0x000000ff, 768); | |
| 2057 | mcd212_update_region_arrays(machine); | |
| 2019 | 2058 | } |
| 2020 | 2059 | break; |
| 2021 | 2060 | case 0xdc: // Weight Factor B |
| 2022 | 2061 | if(channel == 1) |
| 2023 | 2062 | { |
| 2024 | 2063 | verboselog(machine, 6, " %04xxxxx: %d: Weight Factor B = %08x\n", channel * 0x20, channel, value ); |
| 2025 | mcd212.channel[channel].weight_factor_b = value; | |
| 2064 | memset(mcd212.channel[channel].weight_factor_b, value & 0x000000ff, 768); | |
| 2065 | mcd212_update_region_arrays(machine); | |
| 2026 | 2066 | } |
| 2027 | 2067 | break; |
| 2028 | 2068 | } |
| 2029 | 2069 | } |
| 2030 | 2070 | |
| 2031 | ||
| 2071 | static void mcd212_set_vsr(int channel, UINT32 value) | |
| 2032 | 2072 | { |
| 2033 | 2073 | mcd212.channel[channel].vsr = value & 0x0000ffff; |
| 2034 | 2074 | mcd212.channel[channel].dcr &= 0xffc0; |
| 2035 | 2075 | mcd212.channel[channel].dcr |= (value >> 16) & 0x003f; |
| 2036 | 2076 | } |
| 2037 | 2077 | |
| 2038 | ||
| 2078 | static UINT32 mcd212_get_vsr(int channel) | |
| 2039 | 2079 | { |
| 2040 | 2080 | return ((mcd212.channel[channel].dcr & 0x3f) << 16) | mcd212.channel[channel].vsr; |
| 2041 | 2081 | } |
| 2042 | 2082 | |
| 2043 | ||
| 2083 | static void mcd212_set_dcp(int channel, UINT32 value) | |
| 2044 | 2084 | { |
| 2045 | 2085 | mcd212.channel[channel].dcp = value & 0x0000ffff; |
| 2046 | 2086 | mcd212.channel[channel].ddr &= 0xffc0; |
| 2047 | 2087 | mcd212.channel[channel].ddr |= (value >> 16) & 0x003f; |
| 2048 | 2088 | } |
| 2049 | 2089 | |
| 2050 | ||
| 2090 | static UINT32 mcd212_get_dcp(int channel) | |
| 2051 | 2091 | { |
| 2052 | 2092 | return ((mcd212.channel[channel].ddr & 0x3f) << 16) | mcd212.channel[channel].dcp; |
| 2053 | 2093 | } |
| 2054 | 2094 | |
| 2055 | ||
| 2095 | static void mcd212_set_display_parameters(int channel, UINT8 value) | |
| 2056 | 2096 | { |
| 2057 | 2097 | mcd212.channel[channel].ddr &= 0xf0ff; |
| 2058 | 2098 | mcd212.channel[channel].ddr |= (value & 0x0f) << 8; |
| r6079 | r6080 | |
| 2060 | 2100 | mcd212.channel[channel].dcr |= (value & 0x10) << 7; |
| 2061 | 2101 | } |
| 2062 | 2102 | |
| 2063 | ||
| 2103 | static void mcd212_process_ica(running_machine *machine, int channel) | |
| 2064 | 2104 | { |
| 2065 | 2105 | UINT16 *ica = channel ? planeb : planea; |
| 2066 | 2106 | UINT32 addr = 0x000400/2; |
| r6079 | r6080 | |
| 2143 | 2183 | } |
| 2144 | 2184 | } |
| 2145 | 2185 | |
| 2146 | ||
| 2186 | static void mcd212_process_dca(running_machine *machine, int channel) | |
| 2147 | 2187 | { |
| 2148 | 2188 | UINT16 *dca = channel ? planeb : planea; |
| 2149 | 2189 | UINT32 addr = (mcd212.channel[channel].dca & 0x0007ffff) / 2; //(mcd212_get_dcp(channel) & 0x0007ffff) / 2; // mcd212.channel[channel].dca / 2; |
| r6079 | r6080 | |
| 2322 | 2362 | return 0; |
| 2323 | 2363 | } |
| 2324 | 2364 | |
| 2325 | ||
| 2365 | static void mcd212_update | |
| 2326 | 2366 | { |
| 2327 | if(mcd212.channel[0].image_coding_method & MCD212_ICM_NR) | |
| 2367 | int x = 0; | |
| 2368 | for(x = 0; x < 768; x++) | |
| 2328 | 2369 | { |
| 2329 | int reg = 0; | |
| 2330 | int flag = 0; | |
| 2370 | if(mcd212.channel[0].image_coding_method & MCD212_ICM_NR) | |
| 2371 | { | |
| 2372 | int reg = 0; | |
| 2373 | int flag = 0; | |
| 2331 | 2374 | |
| 2332 | for(flag = 0; flag < 2; flag++) | |
| 2375 | for(flag = 0; flag < 2; flag++) | |
| 2376 | { | |
| 2377 | for(reg = 0; reg < 4; reg++) | |
| 2378 | { | |
| 2379 | if(x > (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_X)) | |
| 2380 | { | |
| 2381 | break; | |
| 2382 | } | |
| 2383 | if(x == (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_X)) | |
| 2384 | { | |
| 2385 | switch(mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_OP) | |
| 2386 | { | |
| 2387 | case 0: // End of region control for line | |
| 2388 | break; | |
| 2389 | case 1: | |
| 2390 | case 2: | |
| 2391 | case 3: // Not used | |
| 2392 | break; | |
| 2393 | case 4: // Change weight of plane A | |
| 2394 | mcd212.channel[0].weight_factor_a[x] = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2395 | break; | |
| 2396 | case 5: // Not used | |
| 2397 | break; | |
| 2398 | case 6: // Change weight of plane B | |
| 2399 | mcd212.channel[1].weight_factor_b[x] = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2400 | break; | |
| 2401 | case 7: // Not used | |
| 2402 | break; | |
| 2403 | case 8: // Reset region flag | |
| 2404 | if(flag) | |
| 2405 | { | |
| 2406 | mcd212.region_flag_1[x] = 0; | |
| 2407 | } | |
| 2408 | else | |
| 2409 | { | |
| 2410 | mcd212.region_flag_0[x] = 0; | |
| 2411 | } | |
| 2412 | break; | |
| 2413 | case 9: // Set region flag | |
| 2414 | if(flag) | |
| 2415 | { | |
| 2416 | mcd212.region_flag_1[x] = 1; | |
| 2417 | } | |
| 2418 | else | |
| 2419 | { | |
| 2420 | mcd212.region_flag_0[x] = 1; | |
| 2421 | } | |
| 2422 | break; | |
| 2423 | case 10: // Not used | |
| 2424 | case 11: // Not used | |
| 2425 | break; | |
| 2426 | case 12: // Reset region flag and change weight of plane A | |
| 2427 | mcd212.channel[0].weight_factor_a[x] = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2428 | if(flag) | |
| 2429 | { | |
| 2430 | mcd212.region_flag_1[x] = 0; | |
| 2431 | } | |
| 2432 | else | |
| 2433 | { | |
| 2434 | mcd212.region_flag_0[x] = 0; | |
| 2435 | } | |
| 2436 | break; | |
| 2437 | case 13: // Set region flag and change weight of plane A | |
| 2438 | mcd212.channel[0].weight_factor_a[x] = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2439 | if(flag) | |
| 2440 | { | |
| 2441 | mcd212.region_flag_1[x] = 1; | |
| 2442 | } | |
| 2443 | else | |
| 2444 | { | |
| 2445 | mcd212.region_flag_0[x] = 1; | |
| 2446 | } | |
| 2447 | break; | |
| 2448 | case 14: // Reset region flag and change weight of plane B | |
| 2449 | mcd212.channel[1].weight_factor_b[x] = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2450 | if(flag) | |
| 2451 | { | |
| 2452 | mcd212.region_flag_1[x] = 0; | |
| 2453 | } | |
| 2454 | else | |
| 2455 | { | |
| 2456 | mcd212.region_flag_0[x] = 0; | |
| 2457 | } | |
| 2458 | break; | |
| 2459 | case 15: // Set region flag and change weight of plane B | |
| 2460 | mcd212.channel[1].weight_factor_b[x] = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2461 | if(flag) | |
| 2462 | { | |
| 2463 | mcd212.region_flag_1[x] = 1; | |
| 2464 | } | |
| 2465 | else | |
| 2466 | { | |
| 2467 | mcd212.region_flag_0[x] = 1; | |
| 2468 | } | |
| 2469 | break; | |
| 2470 | } | |
| 2471 | } | |
| 2472 | } | |
| 2473 | } | |
| 2474 | } | |
| 2475 | else | |
| 2333 | 2476 | { |
| 2334 | for(reg = 0; reg < 4; reg++) | |
| 2477 | int reg = 0; | |
| 2478 | for(reg = 0; reg < 8; reg++) | |
| 2335 | 2479 | { |
| 2336 | if(x == (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_X)) | |
| 2480 | int flag = (mcd212.channel[0].region_control[reg] & MCD212_RC_RF) >> MCD212_RC_RF_SHIFT; | |
| 2481 | if(x > (mcd212.channel[0].region_control[reg] & MCD212_RC_X)) | |
| 2337 | 2482 | { |
| 2338 | switch(mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_OP) | |
| 2483 | return; | |
| 2484 | } | |
| 2485 | if(x == (mcd212.channel[0].region_control[reg] & MCD212_RC_X)) | |
| 2486 | { | |
| 2487 | switch((mcd212.channel[0].region_control[reg] & MCD212_RC_OP) >> MCD212_RC_OP_SHIFT) | |
| 2339 | 2488 | { |
| 2340 | 2489 | case 0: // End of region control for line |
| 2341 | 2490 | break; |
| r6079 | r6080 | |
| 2344 | 2493 | case 3: // Not used |
| 2345 | 2494 | break; |
| 2346 | 2495 | case 4: // Change weight of plane A |
| 2347 | mcd212.channel[0].weight_factor_a = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2496 | mcd212.channel[0].weight_factor_a[x] = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2497 | verboselog(machine, 0, "New weight factor A: %d\n", mcd212.channel[0].weight_factor_a[x]); | |
| 2348 | 2498 | break; |
| 2349 | 2499 | case 5: // Not used |
| 2350 | 2500 | break; |
| 2351 | 2501 | case 6: // Change weight of plane B |
| 2352 | mcd212.channel[1].weight_factor_b = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2502 | mcd212.channel[1].weight_factor_b[x] = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2503 | verboselog(machine, 0, "New weight factor B: %d\n", mcd212.channel[1].weight_factor_b[x]); | |
| 2353 | 2504 | break; |
| 2354 | 2505 | case 7: // Not used |
| 2355 | 2506 | break; |
| 2356 | 2507 | case 8: // Reset region flag |
| 2357 | mcd212.region_flag[flag] = 0; | |
| 2508 | if(flag) | |
| 2509 | { | |
| 2510 | mcd212.region_flag_1[x] = 0; | |
| 2511 | } | |
| 2512 | else | |
| 2513 | { | |
| 2514 | mcd212.region_flag_0[x] = 0; | |
| 2515 | } | |
| 2358 | 2516 | break; |
| 2359 | 2517 | case 9: // Set region flag |
| 2360 | mcd212.region_flag[flag] = 1; | |
| 2518 | if(flag) | |
| 2519 | { | |
| 2520 | mcd212.region_flag_1[x] = 1; | |
| 2521 | } | |
| 2522 | else | |
| 2523 | { | |
| 2524 | mcd212.region_flag_0[x] = 1; | |
| 2525 | } | |
| 2361 | 2526 | break; |
| 2362 | 2527 | case 10: // Not used |
| 2363 | 2528 | case 11: // Not used |
| 2364 | 2529 | break; |
| 2365 | 2530 | case 12: // Reset region flag and change weight of plane A |
| 2366 | mcd212.channel[0].weight_factor_a = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2367 | mcd212.region_flag[flag] = 0; | |
| 2531 | mcd212.channel[0].weight_factor_a[x] = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2532 | if(flag) | |
| 2533 | { | |
| 2534 | mcd212.region_flag_1[x] = 0; | |
| 2535 | } | |
| 2536 | else | |
| 2537 | { | |
| 2538 | mcd212.region_flag_0[x] = 0; | |
| 2539 | } | |
| 2368 | 2540 | break; |
| 2369 | 2541 | case 13: // Set region flag and change weight of plane A |
| 2370 | mcd212.channel[0].weight_factor_a = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2371 | mcd212.region_flag[flag] = 1; | |
| 2542 | mcd212.channel[0].weight_factor_a[x] = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2543 | if(flag) | |
| 2544 | { | |
| 2545 | mcd212.region_flag_1[x] = 1; | |
| 2546 | } | |
| 2547 | else | |
| 2548 | { | |
| 2549 | mcd212.region_flag_0[x] = 1; | |
| 2550 | } | |
| 2372 | 2551 | break; |
| 2373 | 2552 | case 14: // Reset region flag and change weight of plane B |
| 2374 | mcd212.channel[1].weight_factor_b = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2375 | mcd212.region_flag[flag] = 0; | |
| 2553 | mcd212.channel[1].weight_factor_b[x] = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2554 | if(flag) | |
| 2555 | { | |
| 2556 | mcd212.region_flag_1[x] = 0; | |
| 2557 | } | |
| 2558 | else | |
| 2559 | { | |
| 2560 | mcd212.region_flag_0[x] = 0; | |
| 2561 | } | |
| 2376 | 2562 | break; |
| 2377 | 2563 | case 15: // Set region flag and change weight of plane B |
| 2378 | mcd212.channel[1].weight_factor_b = (mcd212.channel[0].region_control[flag*4 + reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2379 | mcd212.region_flag[flag] = 1; | |
| 2564 | mcd212.channel[1].weight_factor_b[x] = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2565 | if(flag) | |
| 2566 | { | |
| 2567 | mcd212.region_flag_1[x] = 1; | |
| 2568 | } | |
| 2569 | else | |
| 2570 | { | |
| 2571 | mcd212.region_flag_0[x] = 1; | |
| 2572 | } | |
| 2380 | 2573 | break; |
| 2381 | 2574 | } |
| 2382 | 2575 | } |
| 2383 | 2576 | } |
| 2384 | 2577 | } |
| 2385 | 2578 | } |
| 2386 | else | |
| 2387 | { | |
| 2388 | int reg = 0; | |
| 2389 | for(reg = 0; reg < 8; reg++) | |
| 2390 | { | |
| 2391 | int flag = (mcd212.channel[0].region_control[reg] & MCD212_RC_RF) >> MCD212_RC_RF_SHIFT; | |
| 2392 | if((mcd212.channel[0].region_control[reg] & MCD212_RC_X) > x) | |
| 2393 | { | |
| 2394 | break; | |
| 2395 | } | |
| 2396 | if(x == (mcd212.channel[0].region_control[reg] & MCD212_RC_X)) | |
| 2397 | { | |
| 2398 | switch((mcd212.channel[0].region_control[reg] & MCD212_RC_OP) >> MCD212_RC_OP_SHIFT) | |
| 2399 | { | |
| 2400 | case 0: // End of region control for line | |
| 2401 | break; | |
| 2402 | case 1: | |
| 2403 | case 2: | |
| 2404 | case 3: // Not used | |
| 2405 | break; | |
| 2406 | case 4: // Change weight of plane A | |
| 2407 | mcd212.channel[0].weight_factor_a = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2408 | verboselog(machine, 0, "New weight factor A: %d\n", mcd212.channel[0].weight_factor_a); | |
| 2409 | break; | |
| 2410 | case 5: // Not used | |
| 2411 | break; | |
| 2412 | case 6: // Change weight of plane B | |
| 2413 | mcd212.channel[1].weight_factor_b = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2414 | verboselog(machine, 0, "New weight factor B: %d\n", mcd212.channel[1].weight_factor_b); | |
| 2415 | break; | |
| 2416 | case 7: // Not used | |
| 2417 | break; | |
| 2418 | case 8: // Reset region flag | |
| 2419 | mcd212.region_flag[flag] = 0; | |
| 2420 | break; | |
| 2421 | case 9: // Set region flag | |
| 2422 | mcd212.region_flag[flag] = 1; | |
| 2423 | break; | |
| 2424 | case 10: // Not used | |
| 2425 | case 11: // Not used | |
| 2426 | break; | |
| 2427 | case 12: // Reset region flag and change weight of plane A | |
| 2428 | mcd212.channel[0].weight_factor_a = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2429 | mcd212.region_flag[flag] = 0; | |
| 2430 | break; | |
| 2431 | case 13: // Set region flag and change weight of plane A | |
| 2432 | mcd212.channel[0].weight_factor_a = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2433 | mcd212.region_flag[flag] = 1; | |
| 2434 | break; | |
| 2435 | case 14: // Reset region flag and change weight of plane B | |
| 2436 | mcd212.channel[1].weight_factor_b = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2437 | mcd212.region_flag[flag] = 0; | |
| 2438 | break; | |
| 2439 | case 15: // Set region flag and change weight of plane B | |
| 2440 | mcd212.channel[1].weight_factor_b = (mcd212.channel[0].region_control[reg] & MCD212_RC_WF) >> MCD212_RC_WF_SHIFT; | |
| 2441 | mcd212.region_flag[flag] = 1; | |
| 2442 | break; | |
| 2443 | } | |
| 2444 | } | |
| 2445 | } | |
| 2446 | } | |
| 2447 | 2579 | } |
| 2448 | 2580 | |
| 2449 | ||
| 2581 | static void mcd212_process_vsr(running_machine *machine, int channel, UINT8 | |
| 2450 | 2582 | { |
| 2451 | 2583 | UINT8 *data = channel ? (UINT8*)planeb : (UINT8*)planea; |
| 2452 | 2584 | UINT32 vsr = mcd212_get_vsr(channel) & 0x0007ffff; |
| r6079 | r6080 | |
| 2455 | 2587 | UINT32 icm_mask = channel ? MCD212_ICM_MODE2 : MCD212_ICM_MODE1; |
| 2456 | 2588 | UINT32 icm_shift = channel ? MCD212_ICM_MODE2_SHIFT : MCD212_ICM_MODE1_SHIFT; |
| 2457 | 2589 | UINT8 icm = (mcd212.channel[0].image_coding_method & icm_mask) >> icm_shift; |
| 2590 | UINT8 *clut_r = mcd212.channel[0].clut_r; | |
| 2591 | UINT8 *clut_g = mcd212.channel[0].clut_g; | |
| 2592 | UINT8 *clut_b = mcd212.channel[0].clut_b; | |
| 2458 | 2593 | |
| 2459 | 2594 | //printf( "vsr before: %08x: ", vsr ); |
| 2460 | 2595 | //fflush(stdout); |
| 2461 | 2596 | |
| 2462 | 2597 | if(!icm || !vsr) |
| 2463 | 2598 | { |
| 2464 | for(; x < 768; x++) | |
| 2465 | { | |
| 2466 | pixels[x++] = 0x00101010; | |
| 2467 | pixels[x] = 0x00101010; | |
| 2468 | } | |
| 2599 | memset(pixels_r, 0x10, 768); | |
| 2600 | memset(pixels_g, 0x10, 768); | |
| 2601 | memset(pixels_b, 0x10, 768); | |
| 2469 | 2602 | return; |
| 2470 | 2603 | } |
| 2471 | 2604 | |
| 2472 | 2605 | while(!done) |
| 2473 | 2606 | { |
| 2474 | UINT8 byte = data[vsr++ ^ 1]; | |
| 2475 | //printf( "%02x ", byte ); | |
| 2476 | //fflush(stdout); | |
| 2607 | UINT8 byte = data[(vsr & 0x0007ffff) ^ 1]; | |
| 2608 | vsr++; | |
| 2477 | 2609 | switch(mcd212.channel[channel].ddr & MCD212_DDR_FT) |
| 2478 | 2610 | { |
| 2479 | 2611 | case MCD212_DDR_FT_BMP: |
| r6079 | r6080 | |
| 2507 | 2639 | bY = bU = bV = 0x80; |
| 2508 | 2640 | break; |
| 2509 | 2641 | } |
| 2510 | for(; x < 768;) | |
| 2642 | for(; x < 768; x += 4) | |
| 2511 | 2643 | { |
| 2512 | 2644 | BYTE68K b0 = byte; |
| 2513 | 2645 | BYTE68K bU1 = bU + mcd212_abDeltaUV[b0]; |
| 2514 | 2646 | BYTE68K bY0 = bY + mcd212_abDeltaY[b0]; |
| 2515 | 2647 | |
| 2516 | BYTE68K b1 = data[vsr | |
| 2648 | BYTE68K b1 = data[(vsr & 0x0007ffff) ^ 1]; | |
| 2517 | 2649 | BYTE68K bV1 = bV + mcd212_abDeltaUV[b1]; |
| 2518 | 2650 | BYTE68K bY1 = bY0 + mcd212_abDeltaY[b1]; |
| 2519 | 2651 | |
| r6079 | r6080 | |
| 2521 | 2653 | BYTE68K bV0 = (bV + bV1) >> 1; |
| 2522 | 2654 | |
| 2523 | 2655 | BYTE68K *pbLimit; |
| 2524 | BYTE68K bB, bG, bR; | |
| 2525 | 2656 | |
| 2657 | vsr++; | |
| 2658 | ||
| 2526 | 2659 | bY = bY0; |
| 2527 | 2660 | bU = bU0; |
| 2528 | 2661 | bV = bV0; |
| 2529 | 2662 | |
| 2530 | 2663 | pbLimit = mcd212_abLimit + bY + BYTE68K_MAX; |
| 2531 | bB = pbLimit[mcd212_abMatrixUB[bU]]; | |
| 2532 | bG = pbLimit[mcd212_abMatrixUG[bU] + mcd212_abMatrixVG[bV]]; | |
| 2533 | bR = pbLimit[mcd212_abMatrixVR[bV]]; | |
| 2534 | 2664 | |
| 2535 | pixels[x++] = (bR << 16) | (bG << 8) | bB; | |
| 2536 | pixels[x++] = (bR << 16) | (bG << 8) | bB; | |
| 2665 | pixels_r[x + 0] = pixels_r[x + 1] = pbLimit[mcd212_abMatrixVR[bV]]; | |
| 2666 | pixels_g[x + 0] = pixels_g[x + 1] = pbLimit[mcd212_abMatrixUG[bU] + mcd212_abMatrixVG[bV]]; | |
| 2667 | pixels_b[x + 0] = pixels_b[x + 1] = pbLimit[mcd212_abMatrixUB[bU]]; | |
| 2537 | 2668 | |
| 2538 | 2669 | bY = bY1; |
| 2539 | 2670 | bU = bU1; |
| 2540 | 2671 | bV = bV1; |
| 2541 | 2672 | |
| 2542 | 2673 | pbLimit = mcd212_abLimit + bY + BYTE68K_MAX; |
| 2543 | bB = pbLimit[mcd212_abMatrixUB[bU]]; | |
| 2544 | bG = pbLimit[mcd212_abMatrixUG[bU] + mcd212_abMatrixVG[bV]]; | |
| 2545 | bR = pbLimit[mcd212_abMatrixVR[bV]]; | |
| 2546 | 2674 | |
| 2547 | pixels[x++] = (bR << 16) | (bG << 8) | bB; | |
| 2548 | pixels[x++] = (bR << 16) | (bG << 8) | bB; | |
| 2675 | pixels_r[x + 2] = pixels_r[x + 3] = pbLimit[mcd212_abMatrixVR[bV]]; | |
| 2676 | pixels_g[x + 2] = pixels_g[x + 3] = pbLimit[mcd212_abMatrixUG[bU] + mcd212_abMatrixVG[bV]]; | |
| 2677 | pixels_b[x + 2] = pixels_b[x + 3] = pbLimit[mcd212_abMatrixUB[bU]]; | |
| 2549 | 2678 | |
| 2550 | byte = data[vsr | |
| 2679 | byte = data[(vsr & 0x0007ffff) ^ 1]; | |
| 2551 | 2680 | |
| 2681 | vsr++; | |
| 2552 | 2682 | } |
| 2553 | mcd212_set_vsr(channel, vsr - 1); | |
| 2683 | mcd212_set_vsr(channel, (vsr - 1) & 0x0007ffff); | |
| 2554 | 2684 | } |
| 2555 | 2685 | else if(icm == 3 || icm == 4) |
| 2556 | 2686 | { |
| 2557 | for(; x < 768; x+ | |
| 2687 | for(; x < 768; x += 2) | |
| 2558 | 2688 | { |
| 2559 | pixels[x++] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2560 | pixels[x] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2561 | byte = data[vsr++ ^ 1]; | |
| 2689 | UINT8 clut_entry = BYTE_TO_CLUT(channel, icm, byte); | |
| 2690 | pixels_r[x + 0] = clut_r[clut_entry]; | |
| 2691 | pixels_g[x + 0] = clut_g[clut_entry]; | |
| 2692 | pixels_b[x + 0] = clut_b[clut_entry]; | |
| 2693 | pixels_r[x + 1] = clut_r[clut_entry]; | |
| 2694 | pixels_g[x + 1] = clut_g[clut_entry]; | |
| 2695 | pixels_b[x + 1] = clut_b[clut_entry]; | |
| 2696 | byte = data[(vsr & 0x0007ffff) ^ 1]; | |
| 2697 | vsr++; | |
| 2562 | 2698 | } |
| 2563 | mcd212_set_vsr(channel, vsr - 1); | |
| 2699 | mcd212_set_vsr(channel, (vsr - 1) & 0x0007ffff); | |
| 2564 | 2700 | } |
| 2565 | 2701 | else if(icm == 11) |
| 2566 | 2702 | { |
| 2567 | for(; x < 768; x+ | |
| 2703 | for(; x < 768; x += 2) | |
| 2568 | 2704 | { |
| 2569 | pixels[x++] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte >> 4)]; | |
| 2570 | pixels[x] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2571 | byte = data[vsr++ ^ 1]; | |
| 2705 | UINT8 even_entry = BYTE_TO_CLUT(channel, icm, byte >> 4); | |
| 2706 | UINT8 odd_entry = BYTE_TO_CLUT(channel, icm, byte); | |
| 2707 | pixels_r[x + 0] = clut_r[even_entry]; | |
| 2708 | pixels_g[x + 0] = clut_g[even_entry]; | |
| 2709 | pixels_b[x + 0] = clut_b[even_entry]; | |
| 2710 | pixels_r[x + 1] = clut_r[odd_entry]; | |
| 2711 | pixels_g[x + 1] = clut_g[odd_entry]; | |
| 2712 | pixels_b[x + 1] = clut_b[odd_entry]; | |
| 2713 | byte = data[(vsr & 0x0007ffff) ^ 1]; | |
| 2714 | vsr++; | |
| 2572 | 2715 | } |
| 2573 | mcd212_set_vsr(channel, vsr - 1); | |
| 2716 | mcd212_set_vsr(channel, (vsr - 1) & 0x0007ffff); | |
| 2574 | 2717 | } |
| 2575 | 2718 | else |
| 2576 | 2719 | { |
| 2577 | 2720 | for(; x < 768; x++) |
| 2578 | 2721 | { |
| 2579 | pixels[x++] = 0x00101010; | |
| 2580 | pixels[x] = 0x00101010; | |
| 2722 | pixels_r[x] = 0x10; | |
| 2723 | pixels_g[x] = 0x10; | |
| 2724 | pixels_b[x] = 0x10; | |
| 2581 | 2725 | } |
| 2582 | 2726 | } |
| 2583 | 2727 | } |
| r6079 | r6080 | |
| 2594 | 2738 | if(byte & 0x80) |
| 2595 | 2739 | { |
| 2596 | 2740 | // Run length |
| 2597 | UINT8 length = data[vsr++ ^ 1]; | |
| 2741 | UINT8 length = data[((vsr++) & 0x0007ffff) ^ 1]; | |
| 2598 | 2742 | if(!length) |
| 2599 | 2743 | { |
| 2744 | UINT8 clut_entry = BYTE_TO_CLUT(channel, icm, byte); | |
| 2745 | UINT8 r = clut_r[clut_entry]; | |
| 2746 | UINT8 g = clut_g[clut_entry]; | |
| 2747 | UINT8 b = clut_b[clut_entry]; | |
| 2600 | 2748 | // Go to the end of the line |
| 2601 | 2749 | for(; x < 768; x++) |
| 2602 | 2750 | { |
| 2603 | pixels[x++] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2604 | pixels[x] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2751 | pixels_r[x] = r; | |
| 2752 | pixels_g[x] = g; | |
| 2753 | pixels_b[x] = b; | |
| 2754 | x++; | |
| 2755 | pixels_r[x] = r; | |
| 2756 | pixels_g[x] = g; | |
| 2757 | pixels_b[x] = b; | |
| 2605 | 2758 | } |
| 2606 | 2759 | done = 1; |
| 2607 | 2760 | mcd212_set_vsr(channel, vsr); |
| r6079 | r6080 | |
| 2609 | 2762 | else |
| 2610 | 2763 | { |
| 2611 | 2764 | int end = x + (length * 2); |
| 2765 | UINT8 clut_entry = BYTE_TO_CLUT(channel, icm, byte); | |
| 2766 | UINT8 r = clut_r[clut_entry]; | |
| 2767 | UINT8 g = clut_g[clut_entry]; | |
| 2768 | UINT8 b = clut_b[clut_entry]; | |
| 2612 | 2769 | for(; x < end && x < 768; x++) |
| 2613 | 2770 | { |
| 2614 | pixels[x++] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2615 | pixels[x] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2771 | pixels_r[x] = r; | |
| 2772 | pixels_g[x] = g; | |
| 2773 | pixels_b[x] = b; | |
| 2774 | x++; | |
| 2775 | pixels_r[x] = r; | |
| 2776 | pixels_g[x] = g; | |
| 2777 | pixels_b[x] = b; | |
| 2616 | 2778 | } |
| 2617 | 2779 | if(x >= 768) |
| 2618 | 2780 | { |
| r6079 | r6080 | |
| 2624 | 2786 | else |
| 2625 | 2787 | { |
| 2626 | 2788 | // Single pixel |
| 2627 | pixels[x++] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2628 | pixels[x++] = mcd212.channel[0].clut[BYTE_TO_CLUT(channel, icm, byte)]; | |
| 2789 | UINT8 clut_entry = BYTE_TO_CLUT(channel, icm, byte); | |
| 2790 | pixels_r[x] = clut_r[clut_entry]; | |
| 2791 | pixels_g[x] = clut_g[clut_entry]; | |
| 2792 | pixels_b[x] = clut_b[clut_entry]; | |
| 2793 | x++; | |
| 2794 | pixels_r[x] = clut_r[clut_entry]; | |
| 2795 | pixels_g[x] = clut_g[clut_entry]; | |
| 2796 | pixels_b[x] = clut_b[clut_entry]; | |
| 2797 | x++; | |
| 2629 | 2798 | if(x >= 768) |
| 2630 | 2799 | { |
| 2631 | 2800 | done = 1; |
| r6079 | r6080 | |
| 2651 | 2820 | 0x00101010, 0x001010e6, 0x0010e610, 0x0010e6e6, 0x00e61010, 0x00e610e6, 0x00e6e610, 0x00e6e6e6 |
| 2652 | 2821 | }; |
| 2653 | 2822 | |
| 2654 | ||
| 2823 | static void mcd212_draw_cursor(running_machine *machine, UINT32 *scanline, int y) | |
| 2655 | 2824 | { |
| 2656 | 2825 | if(mcd212.channel[0].cursor_control & MCD212_CURCNT_EN) |
| 2657 | 2826 | { |
| r6079 | r6080 | |
| 2696 | 2865 | } |
| 2697 | 2866 | } |
| 2698 | 2867 | |
| 2699 | ||
| 2868 | static void mcd212_mix_lines(running_machine *machine, UINT8 | |
| 2700 | 2869 | { |
| 2701 | 2870 | int x = 0; |
| 2702 | 2871 | UINT32 backdrop = mcd212_4bpp_color[mcd212.channel[0].backdrop_color]; |
| 2872 | UINT8 transparency_mode_a = (mcd212.channel[0].transparency_control >> 0) & 0x0f; | |
| 2873 | UINT8 transparency_mode_b = (mcd212.channel[0].transparency_control >> 8) & 0x0f; | |
| 2874 | UINT8 transparent_color_a_r = (UINT8)(mcd212.channel[0].transparent_color_a >> 16); | |
| 2875 | UINT8 transparent_color_a_g = (UINT8)(mcd212.channel[0].transparent_color_a >> 8); | |
| 2876 | UINT8 transparent_color_a_b = (UINT8)(mcd212.channel[0].transparent_color_a >> 0); | |
| 2877 | UINT8 transparent_color_b_r = (UINT8)(mcd212.channel[1].transparent_color_b >> 16); | |
| 2878 | UINT8 transparent_color_b_g = (UINT8)(mcd212.channel[1].transparent_color_b >> 8); | |
| 2879 | UINT8 transparent_color_b_b = (UINT8)(mcd212.channel[1].transparent_color_b >> 0); | |
| 2703 | 2880 | for(x = 0; x < 768; x++) |
| 2704 | 2881 | { |
| 2705 | 2882 | out[x] = backdrop; |
| 2706 | mcd212_process_region(machine, 0, x); | |
| 2707 | mcd212_process_region(machine, 1, x); | |
| 2708 | 2883 | if(!(mcd212.channel[0].transparency_control & MCD212_TCR_DISABLE_MX)) |
| 2709 | 2884 | { |
| 2710 | INT32 weight_a = mcd212.channel[0].weight_factor_a; | |
| 2711 | INT32 weight_b = mcd212.channel[1].weight_factor_b; | |
| 2712 | INT32 ar = (plane_a[x] >> 16) & 0x000000ff; | |
| 2713 | INT32 ag = (plane_a[x] >> 8) & 0x000000ff; | |
| 2714 | INT32 ab = (plane_a[x] >> 0) & 0x000000ff; | |
| 2715 | INT32 br = (plane_b[x] >> 16) & 0x000000ff; | |
| 2716 | INT32 bg = (plane_b[x] >> 8) & 0x000000ff; | |
| 2717 | INT32 bb = (plane_b[x] >> 0) & 0x000000ff; | |
| 2718 | UINT8 abr = MCD212_LIM((MCD212_LIM(ar - 16) * weight_a) / 64 + (MCD212_LIM(br - 16) * weight_b) / 64 + 16); | |
| 2719 | UINT8 abg = MCD212_LIM((MCD212_LIM(ag - 16) * weight_a) / 64 + (MCD212_LIM(bg - 16) * weight_b) / 64 + 16); | |
| 2720 | UINT8 abb = MCD212_LIM((MCD212_LIM(ab - 16) * weight_a) / 64 + (MCD212_LIM(bb - 16) * weight_b) / 64 + 16); | |
| 2885 | UINT8 abr = MCD212_LIM(((MCD212_LIM((INT32)plane_a_r[x] - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_r[x] - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); | |
| 2886 | UINT8 abg = MCD212_LIM(((MCD212_LIM((INT32)plane_a_g[x] - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_g[x] - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); | |
| 2887 | UINT8 abb = MCD212_LIM(((MCD212_LIM((INT32)plane_a_b[x] - 16) * mcd212.channel[0].weight_factor_a[x]) >> 6) + ((MCD212_LIM((INT32)plane_b_b[x] - 16) * mcd212.channel[1].weight_factor_b[x]) >> 6) + 16); | |
| 2721 | 2888 | out[x] = (abr << 16) | (abg << 8) | abb; |
| 2722 | 2889 | } |
| 2723 | 2890 | else |
| 2724 | 2891 | { |
| 2725 | UINT8 transparency_mode[2] = | |
| 2892 | UINT8 plane_enable_a = 0; | |
| 2893 | UINT8 plane_enable_b = 0; | |
| 2894 | UINT8 plane_a_r_cur = plane_a_r[x]; | |
| 2895 | UINT8 plane_a_g_cur = plane_a_g[x]; | |
| 2896 | UINT8 plane_a_b_cur = plane_a_b[x]; | |
| 2897 | UINT8 plane_b_r_cur = plane_b_r[x]; | |
| 2898 | UINT8 plane_b_g_cur = plane_b_g[x]; | |
| 2899 | UINT8 plane_b_b_cur = plane_b_b[x]; | |
| 2900 | switch(transparency_mode_a) | |
| 2726 | 2901 | { |
| 2727 | (mcd212.channel[0].transparency_control >> 0) & 0x0f, | |
| 2728 | (mcd212.channel[0].transparency_control >> 8) & 0x0f | |
| 2729 | }; | |
| 2730 | UINT8 plane_enable[2] = | |
| 2902 | case 0: | |
| 2903 | plane_enable_a = 0; | |
| 2904 | break; | |
| 2905 | case 1: | |
| 2906 | plane_enable_a = (plane_a_r_cur != transparent_color_a_r || plane_a_g_cur != transparent_color_a_g || plane_a_b_cur != transparent_color_a_b); | |
| 2907 | break; | |
| 2908 | case 3: | |
| 2909 | plane_enable_a = mcd212.region_flag_0[x]; | |
| 2910 | break; | |
| 2911 | case 4: | |
| 2912 | plane_enable_a = mcd212.region_flag_1[x]; | |
| 2913 | break; | |
| 2914 | case 5: | |
| 2915 | plane_enable_a = (plane_a_r_cur != transparent_color_a_r || plane_a_g_cur != transparent_color_a_g || plane_a_b_cur != transparent_color_a_b || mcd212.region_flag_0[x] == 1); | |
| 2916 | break; | |
| 2917 | case 6: | |
| 2918 | plane_enable_a = (plane_a_r_cur != transparent_color_a_r || plane_a_g_cur != transparent_color_a_g || plane_a_b_cur != transparent_color_a_b || mcd212.region_flag_1[x] == 1); | |
| 2919 | break; | |
| 2920 | case 8: | |
| 2921 | plane_enable_a = 1; | |
| 2922 | break; | |
| 2923 | case 9: | |
| 2924 | plane_enable_a = (plane_a_r_cur == transparent_color_a_r && plane_a_g_cur == transparent_color_a_g && plane_a_b_cur == transparent_color_a_b); | |
| 2925 | break; | |
| 2926 | case 11: | |
| 2927 | plane_enable_a = !mcd212.region_flag_0[x]; | |
| 2928 | break; | |
| 2929 | case 12: | |
| 2930 | plane_enable_a = !mcd212.region_flag_1[x]; | |
| 2931 | break; | |
| 2932 | case 13: | |
| 2933 | plane_enable_a = (plane_a_r_cur == transparent_color_a_r && plane_a_g_cur == transparent_color_a_g && plane_a_b_cur == transparent_color_a_b && mcd212.region_flag_0[x] == 0); | |
| 2934 | break; | |
| 2935 | case 14: | |
| 2936 | plane_enable_a = (plane_a_r_cur == transparent_color_a_r && plane_a_g_cur == transparent_color_a_g && plane_a_b_cur == transparent_color_a_b && mcd212.region_flag_1[x] == 0); | |
| 2937 | break; | |
| 2938 | default: | |
| 2939 | verboselog(machine, 0, "Unhandled transparency mode for plane A: %d\n", transparency_mode_a); | |
| 2940 | plane_enable_a = 1; | |
| 2941 | break; | |
| 2942 | } | |
| 2943 | switch(transparency_mode_b) | |
| 2731 | 2944 | { |
| 2732 | 0, | |
| 2733 | 0 | |
| 2734 | }; | |
| 2735 | int index = 0; | |
| 2736 | for(index = 0; index < 2; index++) | |
| 2737 | { | |
| 2738 | UINT32 *plane = index ? plane_b : plane_a; | |
| 2739 | UINT32 transparent_color = index ? mcd212.channel[1].transparent_color_b : mcd212.channel[0].transparent_color_a; | |
| 2740 | switch(transparency_mode[index]) | |
| 2741 | { | |
| 2742 | case 0: | |
| 2743 | plane_enable[index] = 0; | |
| 2744 | break; | |
| 2745 | case 1: | |
| 2746 | if(plane[x] != transparent_color) | |
| 2747 | { | |
| 2748 | plane_enable[index] = 1; | |
| 2749 | } | |
| 2750 | break; | |
| 2751 | case 5: | |
| 2752 | // Todo | |
| 2753 | if(plane[x] != transparent_color) | |
| 2754 | { | |
| 2755 | plane_enable[index] = 1; | |
| 2756 | } | |
| 2757 | break; | |
| 2758 | case 8: | |
| 2759 | plane_enable[index] = 1; | |
| 2760 | break; | |
| 2761 | case 9: | |
| 2762 | if(plane[x] == transparent_color) | |
| 2763 | { | |
| 2764 | plane_enable[index] = 1; | |
| 2765 | } | |
| 2766 | break; | |
| 2767 | default: | |
| 2768 | verboselog(machine, 0, "Unhandled transparency mode for plane %c: %d\n", index ? 'B' : 'A', transparency_mode[index]); | |
| 2769 | plane_enable[index] = 1; | |
| 2770 | break; | |
| 2771 | } | |
| 2945 | case 0: | |
| 2946 | plane_enable_b = 0; | |
| 2947 | break; | |
| 2948 | case 1: | |
| 2949 | plane_enable_b = (plane_b_r_cur != transparent_color_b_r || plane_b_g_cur != transparent_color_b_g || plane_b_b_cur != transparent_color_b_b); | |
| 2950 | break; | |
| 2951 | case 3: | |
| 2952 | plane_enable_b = mcd212.region_flag_0[x]; | |
| 2953 | break; | |
| 2954 | case 4: | |
| 2955 | plane_enable_b = mcd212.region_flag_1[x]; | |
| 2956 | break; | |
| 2957 | case 5: | |
| 2958 | plane_enable_b = (plane_b_r_cur != transparent_color_b_r || plane_b_g_cur != transparent_color_b_g || plane_b_b_cur != transparent_color_b_b || mcd212.region_flag_0[x] == 1); | |
| 2959 | break; | |
| 2960 | case 6: | |
| 2961 | plane_enable_b = (plane_b_r_cur != transparent_color_b_r || plane_b_g_cur != transparent_color_b_g || plane_b_b_cur != transparent_color_b_b || mcd212.region_flag_1[x] == 1); | |
| 2962 | break; | |
| 2963 | case 8: | |
| 2964 | plane_enable_b = 1; | |
| 2965 | break; | |
| 2966 | case 9: | |
| 2967 | plane_enable_b = (plane_b_r_cur == transparent_color_b_r && plane_b_g_cur == transparent_color_b_g && plane_b_b_cur == transparent_color_b_b); | |
| 2968 | break; | |
| 2969 | case 11: | |
| 2970 | plane_enable_b = !mcd212.region_flag_0[x]; | |
| 2971 | break; | |
| 2972 | case 12: | |
| 2973 | plane_enable_b = !mcd212.region_flag_1[x]; | |
| 2974 | break; | |
| 2975 | case 13: | |
| 2976 | plane_enable_b = (plane_b_r_cur == transparent_color_b_r && plane_b_g_cur == transparent_color_b_g && plane_b_b_cur == transparent_color_b_b && mcd212.region_flag_0[x] == 0); | |
| 2977 | break; | |
| 2978 | case 14: | |
| 2979 | plane_enable_b = (plane_b_r_cur == transparent_color_b_r && plane_b_g_cur == transparent_color_b_g && plane_b_b_cur == transparent_color_b_b && mcd212.region_flag_1[x] == 0); | |
| 2980 | break; | |
| 2981 | default: | |
| 2982 | verboselog(machine, 0, "Unhandled transparency mode for plane B: %d\n", transparency_mode_b); | |
| 2983 | plane_enable_b = 1; | |
| 2984 | break; | |
| 2772 | 2985 | } |
| 2773 | 2986 | switch(mcd212.channel[0].plane_order) |
| 2774 | 2987 | { |
| 2775 | 2988 | case MCD212_POR_AB: |
| 2776 | if(plane_enable | |
| 2989 | if(plane_enable_a | |
| 2777 | 2990 | { |
| 2778 | out[x] = plane_a | |
| 2991 | out[x] = (plane_a_r_cur << 16) | (plane_a_g_cur << 8) | plane_a_b_cur; | |
| 2779 | 2992 | } |
| 2780 | else if(plane_enable | |
| 2993 | else if(plane_enable_b | |
| 2781 | 2994 | { |
| 2782 | out[x] = plane_b | |
| 2995 | out[x] = (plane_b_r_cur << 16) | (plane_b_g_cur << 8) | plane_b_b_cur; | |
| 2783 | 2996 | } |
| 2784 | 2997 | break; |
| 2785 | 2998 | case MCD212_POR_BA: |
| 2786 | if(plane_enable | |
| 2999 | if(plane_enable_b | |
| 2787 | 3000 | { |
| 2788 | out[x] = plane_b | |
| 3001 | out[x] = (plane_b_r_cur << 16) | (plane_b_g_cur << 8) | plane_b_b_cur; | |
| 2789 | 3002 | } |
| 2790 | else if(plane_enable | |
| 3003 | else if(plane_enable_a | |
| 2791 | 3004 | { |
| 2792 | out[x] = plane_a | |
| 3005 | out[x] = (plane_a_r_cur << 16) | (plane_a_g_cur << 8) | plane_a_b_cur; | |
| 2793 | 3006 | } |
| 2794 | 3007 | break; |
| 2795 | 3008 | } |
| r6079 | r6080 | |
| 2800 | 3013 | static void mcd212_draw_scanline(running_machine *machine, int y) |
| 2801 | 3014 | { |
| 2802 | 3015 | bitmap_t *bitmap = tmpbitmap; |
| 2803 | UINT32 plane_a[768]; | |
| 2804 | UINT32 plane_b[768]; | |
| 3016 | UINT8 plane_a_r[768], plane_a_g[768], plane_a_b[768]; | |
| 3017 | UINT8 plane_b_r[768], plane_b_g[768], plane_b_b[768]; | |
| 2805 | 3018 | UINT32 out[768]; |
| 2806 | 3019 | UINT32 *scanline = BITMAP_ADDR32(bitmap, y, 0); |
| 2807 | 3020 | int x; |
| 2808 | mcd212_process_vsr(machine, 0, plane_a); | |
| 2809 | mcd212_process_vsr(machine, 1, plane_b); | |
| 2810 | mcd212_mix_lines(machine, plane_a, plane_b, out); | |
| 3021 | mcd212_process_vsr(machine, 0, plane_a_r, plane_a_g, plane_a_b); | |
| 3022 | mcd212_process_vsr(machine, 1, plane_b_r, plane_b_g, plane_b_b); | |
| 3023 | mcd212_mix_lines(machine, plane_a_r, plane_a_g, plane_a_b, plane_b_r, plane_b_g, plane_b_b, out); | |
| 2811 | 3024 | for(x = 0; x < 768; x++) |
| 2812 | 3025 | { |
| 2813 | 3026 | scanline[x] = out[x]; |
| r6079 | r6080 | |
| 3019 | 3232 | *************************/ |
| 3020 | 3233 | |
| 3021 | 3234 | static MACHINE_DRIVER_START( cdimono1 ) |
| 3022 | MDRV_CPU_ADD("maincpu", SCC68070, CLOCK_A/ | |
| 3235 | MDRV_CPU_ADD("maincpu", SCC68070, CLOCK_A/3) | |
| 3023 | 3236 | MDRV_CPU_PROGRAM_MAP(cdimono1_mem) |
| 3024 | 3237 | |
| 3025 | 3238 | MDRV_SCREEN_ADD("screen", RASTER) |
| Previous | 15994 Revisions | Next |