src/mess/video/vdc.c
| r979 | r980 | |
| 49 | 49 | mame_bitmap *bmp; |
| 50 | 50 | }VCE; |
| 51 | 51 | |
| 52 | | static VDC vdc; |
| 52 | static VDC vdc[2]; |
| 53 | 53 | static VCE vce; |
| 54 | 54 | |
| 55 | 55 | /* Function prototypes */ |
| 56 | 56 | |
| 57 | | void draw_black_line(int line); |
| 58 | | void draw_overscan_line(int line); |
| 59 | | void pce_refresh_line(int bitmap_line, int line); |
| 60 | | void pce_refresh_sprites(int bitmap_line, int line, UINT8 *drawn); |
| 61 | | void vdc_do_dma(void); |
| 57 | static void vdc_advance_line(int which); |
| 58 | static void draw_black_line(int line); |
| 59 | static void draw_overscan_line(int line); |
| 60 | static void pce_refresh_line(int which, int bitmap_line, int line, int external_input, UINT8 *drawn); |
| 61 | static void pce_refresh_sprites(int which, int bitmap_line, int line, UINT8 *drawn); |
| 62 | static void vdc_do_dma(int which); |
| 62 | 63 | |
| 63 | 64 | INTERRUPT_GEN( pce_interrupt ) |
| 64 | 65 | { |
| 65 | | int ret = 0; |
| 66 | | |
| 67 | 66 | /* Draw the last scanline */ |
| 68 | 67 | if ( vce.current_bitmap_line >= 14 && vce.current_bitmap_line < 14 + 242 ) { |
| 69 | 68 | /* We are in the active display area */ |
| 70 | | if ( vdc.current_segment == STATE_VDW ) { |
| 71 | | vdc.y_scroll = ( vdc.current_segment_line == 0 ) ? vdc.vdc_data[BYR].w : ( vdc.y_scroll + 1 ); |
| 72 | | pce_refresh_line( vce.current_bitmap_line, vdc.current_segment_line ); |
| 73 | | } else { |
| 74 | | draw_overscan_line( vce.current_bitmap_line ); |
| 69 | /* First fill the line with the overscan color */ |
| 70 | draw_overscan_line( vce.current_bitmap_line ); |
| 71 | |
| 72 | /* Check if we need to draw more just the overscan color */ |
| 73 | if ( vdc[0].current_segment == STATE_VDW ) { |
| 74 | /* 0 - no sprite and background pixels drawn |
| 75 | 1 - background pixel drawn |
| 76 | otherwise is 2 + sprite# */ |
| 77 | UINT8 drawn[VDC_WPF]; |
| 78 | |
| 79 | /* clear our priority/sprite collision detection buffer. */ |
| 80 | memset(drawn, 0, VDC_WPF); |
| 81 | |
| 82 | vdc[0].y_scroll = ( vdc[0].current_segment_line == 0 ) ? vdc[0].vdc_data[BYR].w : ( vdc[0].y_scroll + 1 ); |
| 83 | |
| 84 | /* Draw VDC #0 background layer */ |
| 85 | pce_refresh_line( 0, vce.current_bitmap_line, vdc[0].current_segment_line, 0, drawn ); |
| 86 | |
| 87 | /* Draw VDC #0 sprite layer */ |
| 88 | if(vdc[0].vdc_data[CR].w & CR_SB) { |
| 89 | pce_refresh_sprites(0, vce.current_bitmap_line, vdc[0].current_segment_line, drawn); |
| 90 | } |
| 75 | 91 | } |
| 76 | 92 | } else { |
| 77 | 93 | /* We are in one of the blanking areas */ |
| r979 | r980 | |
| 80 | 96 | |
| 81 | 97 | /* bump current scanline */ |
| 82 | 98 | vce.current_bitmap_line = ( vce.current_bitmap_line + 1 ) % VDC_LPF; |
| 83 | | vdc.curline += 1; |
| 84 | | vdc.current_segment_line += 1; |
| 85 | | vdc.raster_count += 1; |
| 99 | vdc_advance_line( 0 ); |
| 100 | } |
| 86 | 101 | |
| 87 | | if ( vdc.satb_countdown ) { |
| 88 | | vdc.satb_countdown -= 1; |
| 89 | | if ( vdc.satb_countdown == 0 ) { |
| 90 | | if ( vdc.vdc_data[DCR].w & DCR_DSC ) { |
| 91 | | vdc.status |= VDC_DS; /* set satb done flag */ |
| 102 | static void vdc_advance_line(int which) { |
| 103 | int ret = 0; |
| 104 | |
| 105 | vdc[which].curline += 1; |
| 106 | vdc[which].current_segment_line += 1; |
| 107 | vdc[which].raster_count += 1; |
| 108 | |
| 109 | if ( vdc[which].satb_countdown ) { |
| 110 | vdc[which].satb_countdown -= 1; |
| 111 | if ( vdc[which].satb_countdown == 0 ) { |
| 112 | if ( vdc[which].vdc_data[DCR].w & DCR_DSC ) { |
| 113 | vdc[which].status |= VDC_DS; /* set satb done flag */ |
| 92 | 114 | ret = 1; |
| 93 | 115 | } |
| 94 | 116 | } |
| 95 | 117 | } |
| 96 | 118 | |
| 97 | 119 | if ( vce.current_bitmap_line == 0 ) { |
| 98 | | vdc.current_segment = STATE_VSW; |
| 99 | | vdc.current_segment_line = 0; |
| 100 | | vdc.vblank_triggered = 0; |
| 101 | | vdc.curline = 0; |
| 120 | vdc[which].current_segment = STATE_VSW; |
| 121 | vdc[which].current_segment_line = 0; |
| 122 | vdc[which].vblank_triggered = 0; |
| 123 | vdc[which].curline = 0; |
| 102 | 124 | } |
| 103 | 125 | |
| 104 | | if ( STATE_VSW == vdc.current_segment && vdc.current_segment_line >= ( vdc.vdc_data[VPR].b.l & 0x1F ) ) { |
| 105 | | vdc.current_segment = STATE_VDS; |
| 106 | | vdc.current_segment_line = 0; |
| 126 | if ( STATE_VSW == vdc[which].current_segment && vdc[which].current_segment_line >= ( vdc[which].vdc_data[VPR].b.l & 0x1F ) ) { |
| 127 | vdc[which].current_segment = STATE_VDS; |
| 128 | vdc[which].current_segment_line = 0; |
| 107 | 129 | } |
| 108 | 130 | |
| 109 | | if ( STATE_VDS == vdc.current_segment && vdc.current_segment_line >= vdc.vdc_data[VPR].b.h ) { |
| 110 | | vdc.current_segment = STATE_VDW; |
| 111 | | vdc.current_segment_line = 0; |
| 112 | | vdc.raster_count = 0x40; |
| 131 | if ( STATE_VDS == vdc[which].current_segment && vdc[which].current_segment_line >= vdc[which].vdc_data[VPR].b.h ) { |
| 132 | vdc[which].current_segment = STATE_VDW; |
| 133 | vdc[which].current_segment_line = 0; |
| 134 | vdc[which].raster_count = 0x40; |
| 113 | 135 | } |
| 114 | 136 | |
| 115 | | if ( STATE_VDW == vdc.current_segment && vdc.current_segment_line > ( vdc.vdc_data[VDW].w & 0x01FF ) ) { |
| 116 | | vdc.current_segment = STATE_VCR; |
| 117 | | vdc.current_segment_line = 0; |
| 137 | if ( STATE_VDW == vdc[which].current_segment && vdc[which].current_segment_line > ( vdc[which].vdc_data[VDW].w & 0x01FF ) ) { |
| 138 | vdc[which].current_segment = STATE_VCR; |
| 139 | vdc[which].current_segment_line = 0; |
| 118 | 140 | |
| 119 | 141 | /* Generate VBlank interrupt, sprite DMA */ |
| 120 | | vdc.vblank_triggered = 1; |
| 121 | | if ( vdc.vdc_data[CR].w & CR_VR ) { |
| 122 | | vdc.status |= VDC_VD; |
| 142 | vdc[which].vblank_triggered = 1; |
| 143 | if ( vdc[which].vdc_data[CR].w & CR_VR ) { |
| 144 | vdc[which].status |= VDC_VD; |
| 123 | 145 | ret = 1; |
| 124 | 146 | } |
| 125 | 147 | |
| 126 | 148 | /* do VRAM > SATB DMA if the enable bit is set or the DVSSR reg. was written to */ |
| 127 | | if( ( vdc.vdc_data[DCR].w & DCR_DSR ) || vdc.dvssr_write ) { |
| 149 | if( ( vdc[which].vdc_data[DCR].w & DCR_DSR ) || vdc[which].dvssr_write ) { |
| 128 | 150 | int i; |
| 129 | 151 | |
| 130 | | vdc.dvssr_write = 0; |
| 152 | vdc[which].dvssr_write = 0; |
| 131 | 153 | |
| 132 | 154 | for( i = 0; i < 256; i++ ) { |
| 133 | | vdc.sprite_ram[i] = ( vdc.vram[ ( vdc.vdc_data[DVSSR].w << 1 ) + i * 2 + 1 ] << 8 ) | vdc.vram[ ( vdc.vdc_data[DVSSR].w << 1 ) + i * 2 ]; |
| 155 | vdc[which].sprite_ram[i] = ( vdc[which].vram[ ( vdc[which].vdc_data[DVSSR].w << 1 ) + i * 2 + 1 ] << 8 ) | vdc[which].vram[ ( vdc[which].vdc_data[DVSSR].w << 1 ) + i * 2 ]; |
| 134 | 156 | } |
| 135 | 157 | |
| 136 | 158 | /* generate interrupt if needed */ |
| 137 | | if ( vdc.vdc_data[DCR].w & DCR_DSC ) { |
| 138 | | vdc.satb_countdown = 4; |
| 159 | if ( vdc[which].vdc_data[DCR].w & DCR_DSC ) { |
| 160 | vdc[which].satb_countdown = 4; |
| 139 | 161 | } |
| 140 | 162 | } |
| 141 | 163 | } |
| 142 | 164 | |
| 143 | | if ( STATE_VCR == vdc.current_segment ) { |
| 144 | | if ( vdc.current_segment_line >= 3 && vdc.current_segment_line >= vdc.vdc_data[VCR].b.l ) { |
| 145 | | vdc.current_segment = STATE_VSW; |
| 146 | | vdc.current_segment_line = 0; |
| 147 | | vdc.curline = 0; |
| 165 | if ( STATE_VCR == vdc[which].current_segment ) { |
| 166 | if ( vdc[which].current_segment_line >= 3 && vdc[which].current_segment_line >= vdc[which].vdc_data[VCR].b.l ) { |
| 167 | vdc[which].current_segment = STATE_VSW; |
| 168 | vdc[which].current_segment_line = 0; |
| 169 | vdc[which].curline = 0; |
| 148 | 170 | } |
| 149 | 171 | } |
| 150 | 172 | |
| 151 | 173 | /* generate interrupt on line compare if necessary */ |
| 152 | | if ( vdc.raster_count == vdc.vdc_data[RCR].w && vdc.vdc_data[CR].w & CR_RC ) { |
| 153 | | vdc.status |= VDC_RR; |
| 174 | if ( vdc[which].raster_count == vdc[which].vdc_data[RCR].w && vdc[which].vdc_data[CR].w & CR_RC ) { |
| 175 | vdc[which].status |= VDC_RR; |
| 154 | 176 | ret = 1; |
| 155 | 177 | } |
| 156 | 178 | |
| 157 | 179 | /* handle frame events */ |
| 158 | | if(vdc.curline == 261 && ! vdc.vblank_triggered ) { |
| 180 | if(vdc[which].curline == 261 && ! vdc[which].vblank_triggered ) { |
| 159 | 181 | |
| 160 | | vdc.vblank_triggered = 1; |
| 161 | | if(vdc.vdc_data[CR].w & CR_VR) { /* generate IRQ1 if enabled */ |
| 162 | | vdc.status |= VDC_VD; /* set vblank flag */ |
| 182 | vdc[which].vblank_triggered = 1; |
| 183 | if(vdc[which].vdc_data[CR].w & CR_VR) { /* generate IRQ1 if enabled */ |
| 184 | vdc[which].status |= VDC_VD; /* set vblank flag */ |
| 163 | 185 | ret = 1; |
| 164 | 186 | } |
| 165 | 187 | |
| 166 | 188 | /* do VRAM > SATB DMA if the enable bit is set or the DVSSR reg. was written to */ |
| 167 | | if ( ( vdc.vdc_data[DCR].w & DCR_DSR ) || vdc.dvssr_write ) { |
| 189 | if ( ( vdc[which].vdc_data[DCR].w & DCR_DSR ) || vdc[which].dvssr_write ) { |
| 168 | 190 | int i; |
| 169 | 191 | |
| 170 | | vdc.dvssr_write = 0; |
| 192 | vdc[which].dvssr_write = 0; |
| 171 | 193 | #ifdef MAME_DEBUG |
| 172 | | assert(((vdc.vdc_data[DVSSR].w<<1) + 512) <= 0x10000); |
| 194 | assert(((vdc[which].vdc_data[DVSSR].w<<1) + 512) <= 0x10000); |
| 173 | 195 | #endif |
| 174 | 196 | for( i = 0; i < 256; i++ ) { |
| 175 | | vdc.sprite_ram[i] = ( vdc.vram[ ( vdc.vdc_data[DVSSR].w << 1 ) + i * 2 + 1 ] << 8 ) | vdc.vram[ ( vdc.vdc_data[DVSSR].w << 1 ) + i * 2 ]; |
| 197 | vdc[which].sprite_ram[i] = ( vdc[which].vram[ ( vdc[which].vdc_data[DVSSR].w << 1 ) + i * 2 + 1 ] << 8 ) | vdc[which].vram[ ( vdc[which].vdc_data[DVSSR].w << 1 ) + i * 2 ]; |
| 176 | 198 | } |
| 177 | 199 | |
| 178 | 200 | /* generate interrupt if needed */ |
| 179 | | if(vdc.vdc_data[DCR].w & DCR_DSC) { |
| 180 | | vdc.satb_countdown = 4; |
| 201 | if(vdc[which].vdc_data[DCR].w & DCR_DSC) { |
| 202 | vdc[which].satb_countdown = 4; |
| 181 | 203 | } |
| 182 | 204 | } |
| 183 | 205 | } |
| r979 | r980 | |
| 195 | 217 | memset(&vce, 0, sizeof(vce)); |
| 196 | 218 | |
| 197 | 219 | /* allocate VRAM */ |
| 198 | | vdc.vram = auto_malloc(0x10000); |
| 199 | | memset(vdc.vram, 0, 0x10000); |
| 220 | vdc[0].vram = auto_malloc(0x10000); |
| 221 | vdc[1].vram = auto_malloc(0x10000); |
| 222 | memset(vdc[0].vram, 0, 0x10000); |
| 223 | memset(vdc[1].vram, 0, 0x10000); |
| 200 | 224 | |
| 201 | 225 | /* create display bitmap */ |
| 202 | 226 | vce.bmp = auto_bitmap_alloc(machine->screen[0].width, machine->screen[0].height, machine->screen[0].format); |
| 203 | 227 | |
| 204 | | vdc.inc = 1; |
| 228 | vdc[0].inc = 1; |
| 229 | vdc[1].inc = 1; |
| 205 | 230 | } |
| 206 | 231 | |
| 207 | 232 | |
| r979 | r980 | |
| 212 | 237 | return 0; |
| 213 | 238 | } |
| 214 | 239 | |
| 215 | | void draw_black_line(int line) |
| 240 | static void draw_black_line(int line) |
| 216 | 241 | { |
| 217 | 242 | int i; |
| 218 | 243 | |
| r979 | r980 | |
| 223 | 248 | line_buffer[i] = get_black_pen( Machine ); |
| 224 | 249 | } |
| 225 | 250 | |
| 226 | | void draw_overscan_line(int line) |
| 251 | static void draw_overscan_line(int line) |
| 227 | 252 | { |
| 228 | 253 | int i; |
| 229 | 254 | |
| r979 | r980 | |
| 238 | 263 | |
| 239 | 264 | } |
| 240 | 265 | |
| 241 | | void vram_write(offs_t offset, UINT8 data) |
| 266 | static void vram_write(int which, offs_t offset, UINT8 data) |
| 242 | 267 | { |
| 243 | 268 | if(offset & 0x10000) |
| 244 | 269 | { |
| 245 | | logerror("Write to VRAM offset %05X\n", offset); |
| 270 | logerror("VDC #%d: Write to VRAM offset %05X\n", which, offset); |
| 246 | 271 | return; |
| 247 | 272 | } |
| 248 | 273 | else |
| 249 | 274 | { |
| 250 | | vdc.vram[offset] = data; |
| 275 | vdc[which].vram[offset] = data; |
| 251 | 276 | } |
| 252 | 277 | } |
| 253 | 278 | |
| 254 | | UINT8 vram_read(offs_t offset) |
| 279 | static UINT8 vram_read(int which, offs_t offset) |
| 255 | 280 | { |
| 256 | 281 | UINT8 temp; |
| 257 | 282 | |
| 258 | 283 | if(offset & 0x10000) |
| 259 | 284 | { |
| 260 | | temp = vdc.vram[offset & 0xFFFF]; |
| 285 | temp = vdc[which].vram[offset & 0xFFFF]; |
| 261 | 286 | } |
| 262 | 287 | else |
| 263 | 288 | { |
| 264 | | temp = vdc.vram[offset]; |
| 289 | temp = vdc[which].vram[offset]; |
| 265 | 290 | } |
| 266 | 291 | |
| 267 | 292 | return temp; |
| 268 | 293 | } |
| 269 | 294 | |
| 270 | 295 | |
| 271 | | WRITE8_HANDLER ( vdc_w ) |
| 296 | static void vdc_w( int which, offs_t offset, UINT8 data ) |
| 272 | 297 | { |
| 273 | 298 | switch(offset&3) |
| 274 | 299 | { |
| 275 | 300 | case 0x00: /* VDC register select */ |
| 276 | | vdc.vdc_register = (data & 0x1F); |
| 301 | vdc[which].vdc_register = (data & 0x1F); |
| 277 | 302 | break; |
| 278 | 303 | |
| 279 | 304 | case 0x02: /* VDC data (LSB) */ |
| 280 | | vdc.vdc_data[vdc.vdc_register].b.l = data; |
| 281 | | switch(vdc.vdc_register) |
| 305 | vdc[which].vdc_data[vdc[which].vdc_register].b.l = data; |
| 306 | switch(vdc[which].vdc_register) |
| 282 | 307 | { |
| 283 | 308 | case VxR: /* LSB of data to write to VRAM */ |
| 284 | | vdc.vdc_latch = data; |
| 309 | vdc[which].vdc_latch = data; |
| 285 | 310 | break; |
| 286 | 311 | |
| 287 | 312 | case BYR: |
| 288 | | vdc.y_scroll=vdc.vdc_data[BYR].w; |
| 313 | vdc[which].y_scroll=vdc[which].vdc_data[BYR].w; |
| 289 | 314 | break; |
| 290 | 315 | |
| 291 | 316 | case HDR: |
| 292 | | vdc.physical_width = ((data & 0x003F) + 1) << 3; |
| 317 | vdc[which].physical_width = ((data & 0x003F) + 1) << 3; |
| 293 | 318 | break; |
| 294 | 319 | |
| 295 | 320 | case VDW: |
| 296 | | vdc.physical_height &= 0xFF00; |
| 297 | | vdc.physical_height |= (data & 0xFF); |
| 298 | | vdc.physical_height &= 0x01FF; |
| 321 | vdc[which].physical_height &= 0xFF00; |
| 322 | vdc[which].physical_height |= (data & 0xFF); |
| 323 | vdc[which].physical_height &= 0x01FF; |
| 299 | 324 | break; |
| 300 | 325 | |
| 301 | 326 | case LENR: |
| r979 | r980 | |
| 311 | 336 | break; |
| 312 | 337 | |
| 313 | 338 | case 0x03: /* VDC data (MSB) */ |
| 314 | | vdc.vdc_data[vdc.vdc_register].b.h = data; |
| 315 | | switch(vdc.vdc_register) |
| 339 | vdc[which].vdc_data[vdc[which].vdc_register].b.h = data; |
| 340 | switch(vdc[which].vdc_register) |
| 316 | 341 | { |
| 317 | 342 | case VxR: /* MSB of data to write to VRAM */ |
| 318 | | vram_write(vdc.vdc_data[MAWR].w*2+0, vdc.vdc_latch); |
| 319 | | vram_write(vdc.vdc_data[MAWR].w*2+1, data); |
| 320 | | vdc.vdc_data[MAWR].w += vdc.inc; |
| 343 | vram_write(which, vdc[which].vdc_data[MAWR].w*2+0, vdc[which].vdc_latch); |
| 344 | vram_write(which, vdc[which].vdc_data[MAWR].w*2+1, data); |
| 345 | vdc[which].vdc_data[MAWR].w += vdc[which].inc; |
| 321 | 346 | break; |
| 322 | 347 | |
| 323 | 348 | case CR: |
| 324 | 349 | { |
| 325 | | static unsigned char inctab[] = {1, 32, 64, 128}; |
| 326 | | vdc.inc = inctab[(data >> 3) & 3]; |
| 350 | static const unsigned char inctab[] = {1, 32, 64, 128}; |
| 351 | vdc[which].inc = inctab[(data >> 3) & 3]; |
| 327 | 352 | } |
| 328 | 353 | break; |
| 329 | 354 | |
| 330 | 355 | case VDW: |
| 331 | | vdc.physical_height &= 0x00FF; |
| 332 | | vdc.physical_height |= (data << 8); |
| 333 | | vdc.physical_height &= 0x01FF; |
| 356 | vdc[which].physical_height &= 0x00FF; |
| 357 | vdc[which].physical_height |= (data << 8); |
| 358 | vdc[which].physical_height &= 0x01FF; |
| 334 | 359 | break; |
| 335 | 360 | |
| 336 | 361 | case DVSSR: |
| 337 | 362 | /* Force VRAM <> SATB DMA for this frame */ |
| 338 | | vdc.dvssr_write = 1; |
| 363 | vdc[which].dvssr_write = 1; |
| 339 | 364 | break; |
| 340 | 365 | |
| 341 | 366 | case BYR: |
| 342 | | vdc.y_scroll=vdc.vdc_data[BYR].w; |
| 367 | vdc[which].y_scroll=vdc[which].vdc_data[BYR].w; |
| 343 | 368 | break; |
| 344 | 369 | |
| 345 | 370 | case LENR: |
| 346 | | vdc_do_dma(); |
| 371 | vdc_do_dma( which ); |
| 347 | 372 | break; |
| 348 | 373 | case SOUR: |
| 349 | 374 | // logerror("SOUR MSB = %02X\n", data); |
| r979 | r980 | |
| 356 | 381 | } |
| 357 | 382 | } |
| 358 | 383 | |
| 359 | | |
| 360 | | READ8_HANDLER ( vdc_r ) |
| 384 | static UINT8 vdc_r( int which, offs_t offset ) |
| 361 | 385 | { |
| 362 | 386 | int temp = 0; |
| 363 | 387 | switch(offset&3) |
| 364 | 388 | { |
| 365 | 389 | case 0x00: |
| 366 | | temp = vdc.status; |
| 367 | | vdc.status &= ~(VDC_VD | VDC_RR | VDC_CR | VDC_OR | VDC_DS); |
| 390 | temp = vdc[which].status; |
| 391 | vdc[which].status &= ~(VDC_VD | VDC_RR | VDC_CR | VDC_OR | VDC_DS); |
| 368 | 392 | cpunum_set_input_line(0,0,CLEAR_LINE); |
| 369 | 393 | break; |
| 370 | 394 | |
| 371 | 395 | case 0x02: |
| 372 | | temp = vram_read(vdc.vdc_data[MARR].w*2+0); |
| 396 | temp = vram_read(which, vdc[which].vdc_data[MARR].w*2+0); |
| 373 | 397 | break; |
| 374 | 398 | |
| 375 | 399 | case 0x03: |
| 376 | | temp = vram_read(vdc.vdc_data[MARR].w*2+1); |
| 377 | | if ( vdc.vdc_register ==VxR ) { |
| 378 | | vdc.vdc_data[MARR].w += vdc.inc; |
| 400 | temp = vram_read(which, vdc[which].vdc_data[MARR].w*2+1); |
| 401 | if ( vdc[which].vdc_register ==VxR ) { |
| 402 | vdc[which].vdc_data[MARR].w += vdc[which].inc; |
| 379 | 403 | } |
| 380 | 404 | break; |
| 381 | 405 | } |
| 382 | 406 | return (temp); |
| 383 | 407 | } |
| 384 | 408 | |
| 409 | WRITE8_HANDLER( vdc_0_w ) { vdc_w( 0, offset, data ); } |
| 410 | WRITE8_HANDLER( vdc_1_w ) { vdc_w( 1, offset, data ); } |
| 411 | READ8_HANDLER( vdc_0_r ) { return vdc_r( 0, offset ); } |
| 412 | READ8_HANDLER( vdc_1_r ) { return vdc_r( 1, offset ); } |
| 385 | 413 | |
| 386 | 414 | PALETTE_INIT( vce ) { |
| 387 | 415 | int i; |
| r979 | r980 | |
| 447 | 475 | } |
| 448 | 476 | |
| 449 | 477 | |
| 450 | | void pce_refresh_line(int bitmap_line, int line) |
| 478 | static void pce_refresh_line(int which, int bitmap_line, int line, int external_input, UINT8 *drawn) |
| 451 | 479 | { |
| 452 | 480 | static int width_table[4] = {5, 6, 7, 7}; |
| 453 | 481 | |
| 454 | | int scroll_y = ( vdc.y_scroll & 0x01FF); |
| 455 | | int scroll_x = (vdc.vdc_data[BXR].w & 0x03FF); |
| 482 | int scroll_y = ( vdc[which].y_scroll & 0x01FF); |
| 483 | int scroll_x = (vdc[which].vdc_data[BXR].w & 0x03FF); |
| 456 | 484 | int nt_index; |
| 457 | 485 | |
| 458 | 486 | /* is virtual map 32 or 64 characters tall ? (256 or 512 pixels) */ |
| 459 | | int v_line = (scroll_y) & (vdc.vdc_data[MWR].w & 0x0040 ? 0x1FF : 0x0FF); |
| 487 | int v_line = (scroll_y) & (vdc[which].vdc_data[MWR].w & 0x0040 ? 0x1FF : 0x0FF); |
| 460 | 488 | |
| 461 | 489 | /* row within character */ |
| 462 | 490 | int v_row = (v_line & 7); |
| r979 | r980 | |
| 465 | 493 | int nt_row = (v_line >> 3); |
| 466 | 494 | |
| 467 | 495 | /* virtual X size (# bits to shift) */ |
| 468 | | int v_width = width_table[(vdc.vdc_data[MWR].w >> 4) & 3]; |
| 496 | int v_width = width_table[(vdc[which].vdc_data[MWR].w >> 4) & 3]; |
| 469 | 497 | |
| 470 | 498 | /* our line buffer */ |
| 471 | 499 | UINT16 *line_buffer = BITMAP_ADDR16( vce.bmp, bitmap_line, 86 ); |
| 472 | 500 | |
| 473 | 501 | /* pointer to the name table (Background Attribute Table) in VRAM */ |
| 474 | | UINT8 *bat = &(vdc.vram[nt_row << (v_width+1)]); |
| 502 | UINT8 *bat = &(vdc[which].vram[nt_row << (v_width+1)]); |
| 475 | 503 | |
| 476 | | /* 0 - no sprite and background pixels drawn |
| 477 | | 1 - background pixel drawn |
| 478 | | otherwise is 2 + sprite# */ |
| 479 | | UINT8 drawn[VDC_WPF]; |
| 480 | | |
| 481 | 504 | /* Are we in greyscale mode or in color mode? */ |
| 482 | 505 | int color_base = vce.vce_control & 0x80 ? 512 : 0; |
| 483 | 506 | |
| r979 | r980 | |
| 487 | 510 | int cell_palette; |
| 488 | 511 | int x, c, i; |
| 489 | 512 | |
| 490 | | /* clear our priority/sprite collision detection buffer. */ |
| 491 | | memset(drawn, 0, VDC_WPF); |
| 492 | | |
| 493 | 513 | /* character blanking bit */ |
| 494 | | if(!(vdc.vdc_data[CR].w & CR_BB)) |
| 514 | if(!(vdc[which].vdc_data[CR].w & CR_BB)) |
| 495 | 515 | { |
| 496 | 516 | draw_black_line(bitmap_line); |
| 497 | 517 | } |
| r979 | r980 | |
| 500 | 520 | int pixel = 0; |
| 501 | 521 | int phys_x = - ( scroll_x & 0x07 ); |
| 502 | 522 | |
| 503 | | /* First fill line with overscan colour */ |
| 504 | | for ( i = -86; i < VDC_WPF - 86; i++ ) |
| 505 | | line_buffer[i] = Machine->pens[color_base + vce.vce_data[0x100].w]; |
| 506 | | |
| 507 | | for(i=0;i<(vdc.physical_width >> 3) + 1;i++) |
| 523 | for(i=0;i<(vdc[which].physical_width >> 3) + 1;i++) |
| 508 | 524 | { |
| 509 | 525 | nt_index = (i + (scroll_x >> 3)) & ((2 << (v_width-1))-1); |
| 510 | 526 | nt_index *= 2; |
| r979 | r980 | |
| 520 | 536 | /* byte-offset within the VRAM space */ |
| 521 | 537 | cell_pattern_index = ( ( ( bat[nt_index + 1] << 8 ) | bat[nt_index] ) & 0x0FFF) << 5; |
| 522 | 538 | |
| 523 | | b0 = vram_read((cell_pattern_index) + (v_row << 1) + 0x00); |
| 524 | | b1 = vram_read((cell_pattern_index) + (v_row << 1) + 0x01); |
| 525 | | b2 = vram_read((cell_pattern_index) + (v_row << 1) + 0x10); |
| 526 | | b3 = vram_read((cell_pattern_index) + (v_row << 1) + 0x11); |
| 539 | b0 = vram_read(which, (cell_pattern_index) + (v_row << 1) + 0x00); |
| 540 | b1 = vram_read(which, (cell_pattern_index) + (v_row << 1) + 0x01); |
| 541 | b2 = vram_read(which, (cell_pattern_index) + (v_row << 1) + 0x10); |
| 542 | b3 = vram_read(which, (cell_pattern_index) + (v_row << 1) + 0x11); |
| 527 | 543 | |
| 528 | 544 | for(x=0;x<8;x++) |
| 529 | 545 | { |
| r979 | r980 | |
| 537 | 553 | if ( ! ( c & 0x0F ) ) |
| 538 | 554 | c &= 0x0F; |
| 539 | 555 | |
| 540 | | if ( phys_x >= 0 && phys_x < vdc.physical_width ) { |
| 556 | if ( phys_x >= 0 && phys_x < vdc[which].physical_width ) { |
| 541 | 557 | drawn[ phys_x ] = c ? 1 : 0; |
| 542 | | line_buffer[ pixel ] = Machine->pens[color_base + vce.vce_data[c].w]; |
| 558 | if ( c || ! external_input ) |
| 559 | line_buffer[ pixel ] = Machine->pens[color_base + vce.vce_data[c].w]; |
| 543 | 560 | pixel++; |
| 544 | | if ( vdc.physical_width != 512 ) { |
| 545 | | if ( pixel < ( ( ( phys_x + 1 ) * 512 ) / vdc.physical_width ) ) { |
| 546 | | line_buffer[ pixel ] = Machine->pens[color_base + vce.vce_data[c].w]; |
| 561 | if ( vdc[which].physical_width != 512 ) { |
| 562 | if ( pixel < ( ( ( phys_x + 1 ) * 512 ) / vdc[which].physical_width ) ) { |
| 563 | if ( c || ! external_input ) |
| 564 | line_buffer[ pixel ] = Machine->pens[color_base + vce.vce_data[c].w]; |
| 547 | 565 | pixel++; |
| 548 | 566 | } |
| 549 | 567 | } |
| r979 | r980 | |
| 552 | 570 | } |
| 553 | 571 | } |
| 554 | 572 | } |
| 555 | | /* Sprite rendering is independant of BG drawing! */ |
| 556 | | if(vdc.vdc_data[CR].w & CR_SB) |
| 557 | | { |
| 558 | | pce_refresh_sprites(bitmap_line, line, drawn); |
| 559 | | } |
| 560 | 573 | } |
| 561 | 574 | |
| 562 | 575 | |
| 563 | 576 | |
| 564 | | static void conv_obj(int i, int l, int hf, int vf, char *buf) |
| 577 | static void conv_obj(int which, int i, int l, int hf, int vf, char *buf) |
| 565 | 578 | { |
| 566 | 579 | int b0, b1, b2, b3, i0, i1, i2, i3, x; |
| 567 | 580 | int xi; |
| r979 | r980 | |
| 572 | 585 | |
| 573 | 586 | tmp = l + ( i << 5); |
| 574 | 587 | |
| 575 | | b0 = vram_read((tmp + 0x00)<<1); |
| 576 | | b0 |= vram_read(((tmp + 0x00)<<1)+1)<<8; |
| 577 | | b1 = vram_read((tmp + 0x10)<<1); |
| 578 | | b1 |= vram_read(((tmp + 0x10)<<1)+1)<<8; |
| 579 | | b2 = vram_read((tmp + 0x20)<<1); |
| 580 | | b2 |= vram_read(((tmp + 0x20)<<1)+1)<<8; |
| 581 | | b3 = vram_read((tmp + 0x30)<<1); |
| 582 | | b3 |= vram_read(((tmp + 0x30)<<1)+1)<<8; |
| 588 | b0 = vram_read(which, (tmp + 0x00)<<1); |
| 589 | b0 |= vram_read(which, ((tmp + 0x00)<<1)+1)<<8; |
| 590 | b1 = vram_read(which, (tmp + 0x10)<<1); |
| 591 | b1 |= vram_read(which, ((tmp + 0x10)<<1)+1)<<8; |
| 592 | b2 = vram_read(which, (tmp + 0x20)<<1); |
| 593 | b2 |= vram_read(which, ((tmp + 0x20)<<1)+1)<<8; |
| 594 | b3 = vram_read(which, (tmp + 0x30)<<1); |
| 595 | b3 |= vram_read(which, ((tmp + 0x30)<<1)+1)<<8; |
| 583 | 596 | |
| 584 | 597 | for(x=0;x<16;x++) |
| 585 | 598 | { |
| r979 | r980 | |
| 592 | 605 | } |
| 593 | 606 | } |
| 594 | 607 | |
| 595 | | void pce_refresh_sprites(int bitmap_line, int line, UINT8 *drawn) |
| 608 | static void pce_refresh_sprites(int which, int bitmap_line, int line, UINT8 *drawn) |
| 596 | 609 | { |
| 597 | 610 | int i; |
| 598 | 611 | UINT8 sprites_drawn=0; |
| r979 | r980 | |
| 606 | 619 | { |
| 607 | 620 | static const int cgy_table[] = {16, 32, 64, 64}; |
| 608 | 621 | |
| 609 | | int obj_y = (vdc.sprite_ram[(i<<2)+0] & 0x03FF) - 64; |
| 610 | | int obj_x = (vdc.sprite_ram[(i<<2)+1] & 0x03FF) - 32; |
| 611 | | int obj_i = (vdc.sprite_ram[(i<<2)+2] & 0x07FE); |
| 612 | | int obj_a = (vdc.sprite_ram[(i<<2)+3]); |
| 622 | int obj_y = (vdc[which].sprite_ram[(i<<2)+0] & 0x03FF) - 64; |
| 623 | int obj_x = (vdc[which].sprite_ram[(i<<2)+1] & 0x03FF) - 32; |
| 624 | int obj_i = (vdc[which].sprite_ram[(i<<2)+2] & 0x07FE); |
| 625 | int obj_a = (vdc[which].sprite_ram[(i<<2)+3]); |
| 613 | 626 | int cgx = (obj_a >> 8) & 1; /* sprite width */ |
| 614 | 627 | int cgy = (obj_a >> 12) & 3; /* sprite height */ |
| 615 | 628 | int hf = (obj_a >> 11) & 1; /* horizontal flip */ |
| r979 | r980 | |
| 622 | 635 | char buf[16]; |
| 623 | 636 | |
| 624 | 637 | if ((obj_y == -64) || (obj_y > line)) continue; |
| 625 | | if ((obj_x == -32) || (obj_x >= vdc.physical_width)) continue; |
| 638 | if ((obj_x == -32) || (obj_x >= vdc[which].physical_width)) continue; |
| 626 | 639 | |
| 627 | 640 | /* no need to draw an object that's ABOVE where we are. */ |
| 628 | 641 | if((obj_y + obj_h)<line) continue; |
| r979 | r980 | |
| 642 | 655 | sprites_drawn++; |
| 643 | 656 | if(sprites_drawn > 16) |
| 644 | 657 | { |
| 645 | | vdc.status |= VDC_OR; |
| 646 | | if(vdc.vdc_data[CR].w&CR_OV) |
| 658 | vdc[which].status |= VDC_OR; |
| 659 | if(vdc[which].vdc_data[CR].w&CR_OV) |
| 647 | 660 | cpunum_set_input_line(0, 0, ASSERT_LINE); |
| 648 | 661 | continue; /* Should cause an interrupt */ |
| 649 | 662 | } |
| r979 | r980 | |
| 656 | 669 | if(cgx == 0) |
| 657 | 670 | { |
| 658 | 671 | int x; |
| 659 | | int pixel_x = ( ( obj_x * 512 ) / vdc.physical_width ); |
| 672 | int pixel_x = ( ( obj_x * 512 ) / vdc[which].physical_width ); |
| 660 | 673 | |
| 661 | | conv_obj(obj_i + (cgypos << 2), obj_l, hf, vf, buf); |
| 674 | conv_obj(which, obj_i + (cgypos << 2), obj_l, hf, vf, buf); |
| 662 | 675 | |
| 663 | 676 | for(x=0;x<16;x++) |
| 664 | 677 | { |
| 665 | | if(((obj_x + x)<(vdc.physical_width))&&((obj_x + x)>=0)) |
| 678 | if(((obj_x + x)<(vdc[which].physical_width))&&((obj_x + x)>=0)) |
| 666 | 679 | { |
| 667 | 680 | if ( buf[x] ) { |
| 668 | 681 | if( drawn[obj_x+x] < 2 ) { |
| 669 | 682 | if(priority || drawn[obj_x+x] == 0 ) { |
| 670 | 683 | line_buffer[pixel_x] = Machine->pens[color_base + vce.vce_data[0x100 + (palette << 4) + buf[x]].w]; |
| 671 | | if ( vdc.physical_width != 512 ) { |
| 672 | | if ( pixel_x + 1 < ( ( ( obj_x + x + 1 ) * 512 ) / vdc.physical_width ) ) { |
| 684 | if ( vdc[which].physical_width != 512 ) { |
| 685 | if ( pixel_x + 1 < ( ( ( obj_x + x + 1 ) * 512 ) / vdc[which].physical_width ) ) { |
| 673 | 686 | line_buffer[pixel_x + 1] = Machine->pens[color_base + vce.vce_data[0x100 + (palette << 4) + buf[x]].w]; |
| 674 | 687 | } |
| 675 | 688 | } |
| r979 | r980 | |
| 679 | 692 | /* Check for sprite #0 collision */ |
| 680 | 693 | else if (drawn[obj_x+x]==2) |
| 681 | 694 | { |
| 682 | | if(vdc.vdc_data[CR].w&CR_CC) |
| 695 | if(vdc[which].vdc_data[CR].w&CR_CC) |
| 683 | 696 | cpunum_set_input_line(0, 0, ASSERT_LINE); |
| 684 | | vdc.status|=VDC_CR; |
| 697 | vdc[which].status|=VDC_CR; |
| 685 | 698 | } |
| 686 | 699 | } |
| 687 | 700 | } |
| 688 | 701 | pixel_x += 1; |
| 689 | | if ( vdc.physical_width != 512 ) { |
| 690 | | if ( pixel_x < ( ( ( obj_x + x + 1 ) * 512 ) / vdc.physical_width ) ) { |
| 702 | if ( vdc[which].physical_width != 512 ) { |
| 703 | if ( pixel_x < ( ( ( obj_x + x + 1 ) * 512 ) / vdc[which].physical_width ) ) { |
| 691 | 704 | pixel_x += 1; |
| 692 | 705 | } |
| 693 | 706 | } |
| r979 | r980 | |
| 696 | 709 | else |
| 697 | 710 | { |
| 698 | 711 | int x; |
| 699 | | int pixel_x = ( ( obj_x * 512 ) / vdc.physical_width ); |
| 712 | int pixel_x = ( ( obj_x * 512 ) / vdc[which].physical_width ); |
| 700 | 713 | |
| 701 | | conv_obj(obj_i + (cgypos << 2) + (hf ? 2 : 0), obj_l, hf, vf, buf); |
| 714 | conv_obj(which, obj_i + (cgypos << 2) + (hf ? 2 : 0), obj_l, hf, vf, buf); |
| 702 | 715 | |
| 703 | 716 | for(x=0;x<16;x++) |
| 704 | 717 | { |
| 705 | | if(((obj_x + x)<(vdc.physical_width))&&((obj_x + x)>=0)) |
| 718 | if(((obj_x + x)<(vdc[which].physical_width))&&((obj_x + x)>=0)) |
| 706 | 719 | { |
| 707 | 720 | if ( buf[x] ) { |
| 708 | 721 | if( drawn[obj_x+x] < 2 ) { |
| 709 | 722 | if ( priority || drawn[obj_x+x] == 0 ) { |
| 710 | 723 | line_buffer[pixel_x] = Machine->pens[color_base + vce.vce_data[0x100 + (palette << 4) + buf[x]].w]; |
| 711 | | if ( vdc.physical_width != 512 ) { |
| 712 | | if ( pixel_x + 1 < ( ( ( obj_x + x + 1 ) * 512 ) / vdc.physical_width ) ) { |
| 724 | if ( vdc[which].physical_width != 512 ) { |
| 725 | if ( pixel_x + 1 < ( ( ( obj_x + x + 1 ) * 512 ) / vdc[which].physical_width ) ) { |
| 713 | 726 | line_buffer[pixel_x + 1] = Machine->pens[color_base + vce.vce_data[0x100 + (palette << 4) + buf[x]].w]; |
| 714 | 727 | } |
| 715 | 728 | } |
| r979 | r980 | |
| 718 | 731 | } |
| 719 | 732 | /* Check for sprite #0 collision */ |
| 720 | 733 | else if ( drawn[obj_x+x] == 2 ) { |
| 721 | | if(vdc.vdc_data[CR].w&CR_CC) |
| 734 | if(vdc[which].vdc_data[CR].w&CR_CC) |
| 722 | 735 | cpunum_set_input_line(0, 0, ASSERT_LINE); |
| 723 | | vdc.status|=VDC_CR; |
| 736 | vdc[which].status|=VDC_CR; |
| 724 | 737 | } |
| 725 | 738 | } |
| 726 | 739 | } |
| 727 | 740 | pixel_x += 1; |
| 728 | | if ( vdc.physical_width != 512 ) { |
| 729 | | if ( pixel_x < ( ( ( obj_x + x + 1 ) * 512 ) / vdc.physical_width ) ) { |
| 741 | if ( vdc[which].physical_width != 512 ) { |
| 742 | if ( pixel_x < ( ( ( obj_x + x + 1 ) * 512 ) / vdc[which].physical_width ) ) { |
| 730 | 743 | pixel_x += 1; |
| 731 | 744 | } |
| 732 | 745 | } |
| r979 | r980 | |
| 737 | 750 | */ |
| 738 | 751 | sprites_drawn++; |
| 739 | 752 | if( sprites_drawn > 16 ) { |
| 740 | | vdc.status |= VDC_OR; |
| 741 | | if(vdc.vdc_data[CR].w&CR_OV) |
| 753 | vdc[which].status |= VDC_OR; |
| 754 | if(vdc[which].vdc_data[CR].w&CR_OV) |
| 742 | 755 | cpunum_set_input_line(0, 0, ASSERT_LINE); |
| 743 | 756 | } else { |
| 744 | | conv_obj(obj_i + (cgypos << 2) + (hf ? 0 : 2), obj_l, hf, vf, buf); |
| 757 | conv_obj(which, obj_i + (cgypos << 2) + (hf ? 0 : 2), obj_l, hf, vf, buf); |
| 745 | 758 | for(x=0;x<16;x++) |
| 746 | 759 | { |
| 747 | | if(((obj_x + 0x10 + x)<(vdc.physical_width))&&((obj_x + 0x10 + x)>=0)) |
| 760 | if(((obj_x + 0x10 + x)<(vdc[which].physical_width))&&((obj_x + 0x10 + x)>=0)) |
| 748 | 761 | { |
| 749 | 762 | if ( buf[x] ) { |
| 750 | 763 | if( drawn[obj_x+0x10+x] < 2 ) { |
| 751 | 764 | if( priority || drawn[obj_x+0x10+x] == 0 ) { |
| 752 | 765 | line_buffer[pixel_x] = Machine->pens[color_base + vce.vce_data[0x100 + (palette << 4) + buf[x]].w]; |
| 753 | | if ( vdc.physical_width != 512 ) { |
| 754 | | if ( pixel_x + 1 < ( ( ( obj_x + x + 17 ) * 512 ) / vdc.physical_width ) ) { |
| 766 | if ( vdc[which].physical_width != 512 ) { |
| 767 | if ( pixel_x + 1 < ( ( ( obj_x + x + 17 ) * 512 ) / vdc[which].physical_width ) ) { |
| 755 | 768 | line_buffer[pixel_x + 1] = Machine->pens[color_base + vce.vce_data[0x100 + (palette << 4) + buf[x]].w]; |
| 756 | 769 | } |
| 757 | 770 | } |
| r979 | r980 | |
| 760 | 773 | } |
| 761 | 774 | /* Check for sprite #0 collision */ |
| 762 | 775 | else if ( drawn[obj_x+0x10+x]==2 ) { |
| 763 | | if(vdc.vdc_data[CR].w&CR_CC) |
| 776 | if(vdc[which].vdc_data[CR].w&CR_CC) |
| 764 | 777 | cpunum_set_input_line(0, 0, ASSERT_LINE); |
| 765 | | vdc.status|=VDC_CR; |
| 778 | vdc[which].status|=VDC_CR; |
| 766 | 779 | } |
| 767 | 780 | } |
| 768 | 781 | } |
| 769 | 782 | pixel_x += 1; |
| 770 | | if ( vdc.physical_width != 512 ) { |
| 771 | | if ( pixel_x < ( ( ( obj_x + x + 17 ) * 512 ) / vdc.physical_width ) ) { |
| 783 | if ( vdc[which].physical_width != 512 ) { |
| 784 | if ( pixel_x < ( ( ( obj_x + x + 17 ) * 512 ) / vdc[which].physical_width ) ) { |
| 772 | 785 | pixel_x += 1; |
| 773 | 786 | } |
| 774 | 787 | } |
| r979 | r980 | |
| 779 | 792 | } |
| 780 | 793 | } |
| 781 | 794 | |
| 782 | | void vdc_do_dma(void) |
| 795 | static void vdc_do_dma(int which) |
| 783 | 796 | { |
| 784 | | int src = vdc.vdc_data[SOUR].w; |
| 785 | | int dst = vdc.vdc_data[DESR].w; |
| 786 | | int len = vdc.vdc_data[LENR].w; |
| 797 | int src = vdc[which].vdc_data[SOUR].w; |
| 798 | int dst = vdc[which].vdc_data[DESR].w; |
| 799 | int len = vdc[which].vdc_data[LENR].w; |
| 787 | 800 | |
| 788 | | int did = (vdc.vdc_data[DCR].w >> 3) & 1; |
| 789 | | int sid = (vdc.vdc_data[DCR].w >> 2) & 1; |
| 790 | | int dvc = (vdc.vdc_data[DCR].w >> 1) & 1; |
| 801 | int did = (vdc[which].vdc_data[DCR].w >> 3) & 1; |
| 802 | int sid = (vdc[which].vdc_data[DCR].w >> 2) & 1; |
| 803 | int dvc = (vdc[which].vdc_data[DCR].w >> 1) & 1; |
| 791 | 804 | |
| 792 | 805 | do { |
| 793 | 806 | UINT8 l, h; |
| 794 | 807 | |
| 795 | | l = vram_read(src<<1); |
| 796 | | h = vram_read((src<<1) + 1); |
| 808 | l = vram_read(which, src<<1); |
| 809 | h = vram_read(which, (src<<1) + 1); |
| 797 | 810 | |
| 798 | | vram_write(dst<<1,l); |
| 799 | | vram_write(1+(dst<<1),h); |
| 811 | vram_write(which, dst<<1,l); |
| 812 | vram_write(which, 1+(dst<<1),h); |
| 800 | 813 | |
| 801 | 814 | if(sid) src = (src - 1) & 0xFFFF; |
| 802 | 815 | else src = (src + 1) & 0xFFFF; |
| r979 | r980 | |
| 808 | 821 | |
| 809 | 822 | } while (len != 0xFFFF); |
| 810 | 823 | |
| 811 | | vdc.status |= VDC_DV; |
| 812 | | vdc.vdc_data[SOUR].w = src; |
| 813 | | vdc.vdc_data[DESR].w = dst; |
| 814 | | vdc.vdc_data[LENR].w = len; |
| 824 | vdc[which].status |= VDC_DV; |
| 825 | vdc[which].vdc_data[SOUR].w = src; |
| 826 | vdc[which].vdc_data[DESR].w = dst; |
| 827 | vdc[which].vdc_data[LENR].w = len; |
| 815 | 828 | if(dvc) |
| 816 | 829 | { |
| 817 | 830 | cpunum_set_input_line(0, 0, ASSERT_LINE); |