Annotation of uae/src/blitter.c, revision 1.1.1.15

1.1       root        1:  /*
                      2:   * UAE - The Un*x Amiga Emulator
1.1.1.3   root        3:   *
1.1       root        4:   * Custom chip emulation
1.1.1.3   root        5:   *
1.1       root        6:   * (c) 1995 Bernd Schmidt, Alessandro Bissacco
                      7:   */
                      8: 
                      9: #include "sysconfig.h"
                     10: #include "sysdeps.h"
                     11: 
                     12: #include "options.h"
                     13: #include "events.h"
1.1.1.3   root       14: #include "uae.h"
1.1       root       15: #include "memory.h"
                     16: #include "custom.h"
                     17: #include "newcpu.h"
                     18: #include "blitter.h"
                     19: #include "blit.h"
                     20: 
1.1.1.10  root       21: uae_u16 oldvblts;
1.1.1.3   root       22: uae_u16 bltcon0,bltcon1;
                     23: uae_u32 bltapt,bltbpt,bltcpt,bltdpt;
1.1       root       24: 
                     25: int blinea_shift;
1.1.1.3   root       26: static uae_u16 blitlpos, blinea, blineb;
                     27: static uaecptr bltcnxlpt,bltdnxlpt;
1.1       root       28: static int blitline,blitfc,blitfill,blitife,blitdesc,blitsing;
                     29: static int blitonedot,blitsign;
                     30: static long int bltwait;
                     31: 
                     32: struct bltinfo blt_info;
                     33: 
1.1.1.3   root       34: static uae_u8 blit_filltable[256][4][2];
                     35: uae_u32 blit_masktable[BLITTER_MAX_WORDS];
                     36: static uae_u16 blit_trashtable[BLITTER_MAX_WORDS];
1.1       root       37: enum blitter_states bltstate;
                     38: 
1.1.1.14  root       39: static uae_u8 blit_cycle_diagram_start[][10] =
                     40: {
                     41:     { 0, 1, 0 },               /* 0 */
                     42:     { 0, 2, 4,0 },             /* 1 */
                     43:     { 0, 2, 3,0 },             /* 2 */
                     44:     { 2, 3, 3,0, 0,3,4 },      /* 3 */
                     45:     { 0, 3, 2,0,0 },           /* 4 */
                     46:     { 2, 3, 2,0, 0,2,4 },      /* 5 */
                     47:     { 0, 3, 2,3,0 },           /* 6 */
                     48:     { 3, 4, 2,3,0, 0,2,3,4 },  /* 7 */
                     49:     { 0, 2, 1,0 },             /* 8 */
                     50:     { 2, 2, 1,0, 1,4 },                /* 9 */
                     51:     { 0, 2, 1,3 },             /* A */
                     52:     { 3, 3, 1,3,0, 1,3,4 },    /* B */
                     53:     { 2, 3, 1,2, 0,1,2 },      /* C */
                     54:     { 3, 3, 1,2,0, 1,2,4 },    /* D */
                     55:     { 0, 3, 1,2,3 },           /* E */
                     56:     { 4, 4, 1,2,3,0, 1,2,3,4 } /* F */
                     57: };
                     58: 
1.1       root       59: void build_blitfilltable(void)
                     60: {
                     61:     unsigned int d, fillmask;
                     62:     int i;
1.1.1.3   root       63: 
1.1.1.2   root       64:     for (i = 0; i < BLITTER_MAX_WORDS; i++)
                     65:        blit_masktable[i] = 0xFFFF;
1.1.1.3   root       66: 
1.1       root       67:     for (d = 0; d < 256; d++) {
                     68:        for (i = 0; i < 4; i++) {
                     69:            int fc = i & 1;
1.1.1.3   root       70:            uae_u8 data = d;
1.1       root       71:            for (fillmask = 1; fillmask != 0x100; fillmask <<= 1) {
1.1.1.3   root       72:                uae_u16 tmp = data;
1.1       root       73:                if (fc) {
                     74:                    if (i & 2)
                     75:                        data |= fillmask;
                     76:                    else
                     77:                        data ^= fillmask;
                     78:                }
                     79:                if (tmp & fillmask) fc = !fc;
                     80:            }
                     81:            blit_filltable[d][i][0] = data;
                     82:            blit_filltable[d][i][1] = fc;
                     83:        }
                     84:     }
                     85: }
                     86: 
1.1.1.5   root       87: STATIC_INLINE uae_u8 *blit_xlateptr(uaecptr bltpt, int bytecount)
1.1       root       88: {
                     89:     if (!chipmem_bank.check(bltpt,bytecount)) return NULL;
                     90:     return chipmem_bank.xlateaddr(bltpt);
                     91: }
                     92: 
1.1.1.5   root       93: STATIC_INLINE uae_u8 *blit_xlateptr_desc(uaecptr bltpt, int bytecount)
1.1       root       94: {
                     95:     if (!chipmem_bank.check(bltpt-bytecount, bytecount)) return NULL;
                     96:     return chipmem_bank.xlateaddr(bltpt);
                     97: }
                     98: 
1.1.1.3   root       99: static void blitter_dofast(void)
1.1       root      100: {
                    101:     int i,j;
1.1.1.7   root      102:     uaecptr bltadatptr = 0, bltbdatptr = 0, bltcdatptr = 0, bltddatptr = 0;
1.1.1.3   root      103:     uae_u8 mt = bltcon0 & 0xFF;
                    104: 
1.1.1.2   root      105:     blit_masktable[0] = blt_info.bltafwm;
                    106:     blit_masktable[blt_info.hblitsize - 1] &= blt_info.bltalwm;
1.1.1.3   root      107: 
1.1       root      108:     if (bltcon0 & 0x800) {
1.1.1.7   root      109:        bltadatptr = bltapt;
                    110:        bltapt += (blt_info.hblitsize*2 + blt_info.bltamod)*blt_info.vblitsize;
1.1       root      111:     }
                    112:     if (bltcon0 & 0x400) {
1.1.1.7   root      113:        bltbdatptr = bltbpt;
                    114:        bltbpt += (blt_info.hblitsize*2 + blt_info.bltbmod)*blt_info.vblitsize;
1.1       root      115:     }
                    116:     if (bltcon0 & 0x200) {
1.1.1.7   root      117:        bltcdatptr = bltcpt;
                    118:        bltcpt += (blt_info.hblitsize*2 + blt_info.bltcmod)*blt_info.vblitsize;
1.1       root      119:     }
                    120:     if (bltcon0 & 0x100) {
1.1.1.7   root      121:        bltddatptr = bltdpt;
                    122:        bltdpt += (blt_info.hblitsize*2 + blt_info.bltdmod)*blt_info.vblitsize;
1.1       root      123:     }
1.1.1.3   root      124: 
                    125:     if (blitfunc_dofast[mt] && !blitfill)
1.1.1.7   root      126:        (*blitfunc_dofast[mt])(bltadatptr, bltbdatptr, bltcdatptr, bltddatptr, &blt_info);
1.1       root      127:     else {
1.1.1.3   root      128:        uae_u32 blitbhold = blt_info.bltbhold;
                    129:        uae_u32 preva = 0, prevb = 0;
1.1.1.7   root      130:        uaecptr dstp = 0;
1.1.1.2   root      131: 
1.1.1.11  root      132:        /*if (!blitfill) write_log ("minterm %x not present\n",mt); */
1.1.1.3   root      133:        for (j = 0; j < blt_info.vblitsize; j++) {
1.1       root      134:            blitfc = !!(bltcon1 & 0x4);
                    135:            for (i = 0; i < blt_info.hblitsize; i++) {
1.1.1.3   root      136:                uae_u32 bltadat, blitahold;
1.1.1.7   root      137:                if (bltadatptr) {
                    138:                    bltadat = chipmem_wget (bltadatptr);
                    139:                    bltadatptr += 2;
1.1.1.2   root      140:                } else
                    141:                    bltadat = blt_info.bltadat;
                    142:                bltadat &= blit_masktable[i];
1.1.1.3   root      143:                blitahold = (((uae_u32)preva << 16) | bltadat) >> blt_info.blitashift;
1.1.1.2   root      144:                preva = bltadat;
                    145: 
1.1.1.7   root      146:                if (bltbdatptr) {
                    147:                    uae_u16 bltbdat = chipmem_wget (bltbdatptr);
                    148:                    bltbdatptr += 2;
1.1.1.3   root      149:                    blitbhold = (((uae_u32)prevb << 16) | bltbdat) >> blt_info.blitbshift;
1.1.1.2   root      150:                    prevb = bltbdat;
                    151:                }
1.1.1.7   root      152:                if (bltcdatptr) {
                    153:                    blt_info.bltcdat = chipmem_wget (bltcdatptr);
                    154:                    bltcdatptr += 2;
1.1.1.2   root      155:                }
1.1.1.7   root      156:                if (dstp) chipmem_wput (dstp, blt_info.bltddat);
                    157:                blt_info.bltddat = blit_func (blitahold, blitbhold, blt_info.bltcdat, mt) & 0xFFFF;
1.1.1.3   root      158:                if (blitfill) {
                    159:                    uae_u16 d = blt_info.bltddat;
1.1       root      160:                    int ifemode = blitife ? 2 : 0;
                    161:                    int fc1 = blit_filltable[d & 255][ifemode + blitfc][1];
1.1.1.3   root      162:                    blt_info.bltddat = (blit_filltable[d & 255][ifemode + blitfc][0]
1.1       root      163:                                        + (blit_filltable[d >> 8][ifemode + fc1][0] << 8));
                    164:                    blitfc = blit_filltable[d >> 8][ifemode + fc1][1];
                    165:                }
1.1.1.7   root      166:                if (blt_info.bltddat)
                    167:                    blt_info.blitzero = 0;
                    168:                if (bltddatptr) {
                    169:                    dstp = bltddatptr;
                    170:                    bltddatptr += 2;
1.1.1.2   root      171:                }
1.1       root      172:            }
1.1.1.7   root      173:            if (bltadatptr) bltadatptr += blt_info.bltamod;
                    174:            if (bltbdatptr) bltbdatptr += blt_info.bltbmod;
                    175:            if (bltcdatptr) bltcdatptr += blt_info.bltcmod;
                    176:            if (bltddatptr) bltddatptr += blt_info.bltdmod;
1.1.1.3   root      177:        }
1.1.1.7   root      178:        if (dstp) chipmem_wput (dstp, blt_info.bltddat);
1.1.1.2   root      179:        blt_info.bltbhold = blitbhold;
1.1       root      180:     }
1.1.1.2   root      181:     blit_masktable[0] = 0xFFFF;
                    182:     blit_masktable[blt_info.hblitsize - 1] = 0xFFFF;
1.1.1.3   root      183: 
1.1       root      184:     bltstate = BLT_done;
                    185: }
                    186: 
1.1.1.3   root      187: static void blitter_dofast_desc(void)
1.1       root      188: {
                    189:     int i,j;
1.1.1.7   root      190:     uaecptr bltadatptr = 0, bltbdatptr = 0, bltcdatptr = 0, bltddatptr = 0;
1.1.1.3   root      191:     uae_u8 mt = bltcon0 & 0xFF;
                    192: 
1.1.1.2   root      193:     blit_masktable[0] = blt_info.bltafwm;
                    194:     blit_masktable[blt_info.hblitsize - 1] &= blt_info.bltalwm;
1.1.1.3   root      195: 
1.1       root      196:     if (bltcon0 & 0x800) {
1.1.1.7   root      197:        bltadatptr = bltapt;
                    198:        bltapt -= (blt_info.hblitsize*2 + blt_info.bltamod)*blt_info.vblitsize;
1.1       root      199:     }
                    200:     if (bltcon0 & 0x400) {
1.1.1.7   root      201:        bltbdatptr = bltbpt;
                    202:        bltbpt -= (blt_info.hblitsize*2 + blt_info.bltbmod)*blt_info.vblitsize;
1.1       root      203:     }
                    204:     if (bltcon0 & 0x200) {
1.1.1.7   root      205:        bltcdatptr = bltcpt;
                    206:        bltcpt -= (blt_info.hblitsize*2 + blt_info.bltcmod)*blt_info.vblitsize;
1.1       root      207:     }
                    208:     if (bltcon0 & 0x100) {
1.1.1.7   root      209:        bltddatptr = bltdpt;
                    210:        bltdpt -= (blt_info.hblitsize*2 + blt_info.bltdmod)*blt_info.vblitsize;
1.1       root      211:     }
1.1.1.3   root      212:     if (blitfunc_dofast_desc[mt] && !blitfill)
1.1.1.7   root      213:        (*blitfunc_dofast_desc[mt])(bltadatptr, bltbdatptr, bltcdatptr, bltddatptr, &blt_info);
1.1       root      214:     else {
1.1.1.3   root      215:        uae_u32 blitbhold = blt_info.bltbhold;
                    216:        uae_u32 preva = 0, prevb = 0;
1.1.1.7   root      217:        uaecptr dstp = 0;
1.1.1.2   root      218: 
1.1.1.11  root      219: /*     if (!blitfill) write_log ("minterm %x not present\n",mt);*/
1.1.1.3   root      220:        for (j = 0; j < blt_info.vblitsize; j++) {
1.1       root      221:            blitfc = !!(bltcon1 & 0x4);
                    222:            for (i = 0; i < blt_info.hblitsize; i++) {
1.1.1.3   root      223:                uae_u32 bltadat, blitahold;
1.1.1.7   root      224:                if (bltadatptr) {
                    225:                    bltadat = chipmem_wget (bltadatptr);
                    226:                    bltadatptr -= 2;
1.1.1.2   root      227:                } else
                    228:                    bltadat = blt_info.bltadat;
                    229:                bltadat &= blit_masktable[i];
1.1.1.3   root      230:                blitahold = (((uae_u32)bltadat << 16) | preva) >> blt_info.blitdownashift;
1.1.1.2   root      231:                preva = bltadat;
1.1.1.7   root      232:                if (bltbdatptr) {
                    233:                    uae_u16 bltbdat = chipmem_wget (bltbdatptr);
                    234:                    bltbdatptr -= 2;
1.1.1.3   root      235:                    blitbhold = (((uae_u32)bltbdat << 16) | prevb) >> blt_info.blitdownbshift;
1.1.1.2   root      236:                    prevb = bltbdat;
                    237:                }
1.1.1.7   root      238:                if (bltcdatptr) {
                    239:                    blt_info.bltcdat = chipmem_wget (bltcdatptr);
                    240:                    bltcdatptr -= 2;
1.1.1.2   root      241:                }
1.1.1.7   root      242:                if (dstp) chipmem_wput (dstp, blt_info.bltddat);
                    243:                blt_info.bltddat = blit_func (blitahold, blitbhold, blt_info.bltcdat, mt) & 0xFFFF;
1.1.1.3   root      244:                if (blitfill) {
                    245:                    uae_u16 d = blt_info.bltddat;
1.1       root      246:                    int ifemode = blitife ? 2 : 0;
                    247:                    int fc1 = blit_filltable[d & 255][ifemode + blitfc][1];
                    248:                    blt_info.bltddat = (blit_filltable[d & 255][ifemode + blitfc][0]
                    249:                                        + (blit_filltable[d >> 8][ifemode + fc1][0] << 8));
                    250:                    blitfc = blit_filltable[d >> 8][ifemode + fc1][1];
                    251:                }
1.1.1.7   root      252:                if (blt_info.bltddat)
                    253:                    blt_info.blitzero = 0;
                    254:                if (bltddatptr) {
                    255:                    dstp = bltddatptr;
                    256:                    bltddatptr -= 2;
1.1.1.2   root      257:                }
1.1       root      258:            }
1.1.1.7   root      259:            if (bltadatptr) bltadatptr -= blt_info.bltamod;
                    260:            if (bltbdatptr) bltbdatptr -= blt_info.bltbmod;
                    261:            if (bltcdatptr) bltcdatptr -= blt_info.bltcmod;
                    262:            if (bltddatptr) bltddatptr -= blt_info.bltdmod;
1.1.1.3   root      263:        }
1.1.1.7   root      264:        if (dstp) chipmem_wput (dstp, blt_info.bltddat);
1.1.1.2   root      265:        blt_info.bltbhold = blitbhold;
1.1       root      266:     }
1.1.1.2   root      267:     blit_masktable[0] = 0xFFFF;
                    268:     blit_masktable[blt_info.hblitsize - 1] = 0xFFFF;
                    269: 
1.1       root      270:     bltstate = BLT_done;
                    271: }
                    272: 
1.1.1.5   root      273: STATIC_INLINE int blitter_read(void)
1.1       root      274: {
                    275:     if (bltcon0 & 0xe00){
1.1.1.7   root      276:        if (!dmaen(DMA_BLITTER))
                    277:            return 1;
1.1       root      278:        if (bltcon0 & 0x200) blt_info.bltcdat = chipmem_bank.wget(bltcpt);
                    279:     }
                    280:     bltstate = BLT_work;
                    281:     return (bltcon0 & 0xE00) != 0;
                    282: }
                    283: 
1.1.1.5   root      284: STATIC_INLINE int blitter_write(void)
1.1       root      285: {
                    286:     if (blt_info.bltddat) blt_info.blitzero = 0;
                    287:     if ((bltcon0 & 0x100) || blitline){
                    288:        if (!dmaen(DMA_BLITTER)) return 1;
                    289:        chipmem_bank.wput(bltdpt, blt_info.bltddat);
                    290:     }
                    291:     bltstate = BLT_next;
                    292:     return (bltcon0 & 0x100) != 0;
                    293: }
                    294: 
1.1.1.5   root      295: STATIC_INLINE void blitter_line_incx(void)
1.1       root      296: {
                    297:     if (++blinea_shift == 16) {
                    298:        blinea_shift = 0;
                    299:        bltcnxlpt += 2;
                    300:        bltdnxlpt += 2;
                    301:     }
                    302: }
                    303: 
1.1.1.5   root      304: STATIC_INLINE void blitter_line_decx(void)
1.1       root      305: {
                    306:     if (blinea_shift-- == 0) {
                    307:        blinea_shift = 15;
                    308:        bltcnxlpt -= 2;
                    309:        bltdnxlpt -= 2;
                    310:     }
                    311: }
                    312: 
1.1.1.5   root      313: STATIC_INLINE void blitter_line_decy(void)
1.1       root      314: {
                    315:     bltcnxlpt -= blt_info.bltcmod;
                    316:     bltdnxlpt -= blt_info.bltcmod; /* ??? am I wrong or doesn't KS1.3 set bltdmod? */
                    317:     blitonedot = 0;
                    318: }
                    319: 
1.1.1.5   root      320: STATIC_INLINE void blitter_line_incy(void)
1.1       root      321: {
                    322:     bltcnxlpt += blt_info.bltcmod;
                    323:     bltdnxlpt += blt_info.bltcmod; /* ??? */
                    324:     blitonedot = 0;
                    325: }
                    326: 
                    327: static void blitter_line(void)
                    328: {
1.1.1.14  root      329:     uae_u16 blitahold = blinea >> blinea_shift;
                    330:     uae_u16 blitbhold = blineb & 1 ? 0xFFFF : 0;
                    331:     uae_u16 blitchold = blt_info.bltcdat;
1.1       root      332:     blt_info.bltddat = 0;
1.1.1.3   root      333: 
1.1.1.15! root      334:     if (blitsing && blitonedot)
        !           335:        blitahold = 0;
1.1       root      336:     blitonedot = 1;
                    337:     blt_info.bltddat = blit_func(blitahold, blitbhold, blitchold, bltcon0 & 0xFF);
                    338:     if (!blitsign){
1.1.1.3   root      339:        bltapt += (uae_s16)blt_info.bltamod;
1.1       root      340:        if (bltcon1 & 0x10){
                    341:            if (bltcon1 & 0x8)
1.1.1.3   root      342:                blitter_line_decy();
1.1       root      343:            else
1.1.1.3   root      344:                blitter_line_incy();
1.1       root      345:        } else {
                    346:            if (bltcon1 & 0x8)
1.1.1.3   root      347:                blitter_line_decx();
                    348:            else
                    349:                blitter_line_incx();
1.1       root      350:        }
                    351:     } else {
1.1.1.3   root      352:        bltapt += (uae_s16)blt_info.bltbmod;
1.1       root      353:     }
                    354:     if (bltcon1 & 0x10){
                    355:        if (bltcon1 & 0x4)
                    356:            blitter_line_decx();
                    357:        else
                    358:            blitter_line_incx();
                    359:     } else {
                    360:        if (bltcon1 & 0x4)
                    361:            blitter_line_decy();
                    362:        else
                    363:            blitter_line_incy();
                    364:     }
1.1.1.3   root      365:     blitsign = 0 > (uae_s16)bltapt;
1.1       root      366:     bltstate = BLT_write;
                    367: }
                    368: 
1.1.1.5   root      369: STATIC_INLINE void blitter_nxline(void)
1.1       root      370: {
                    371:     bltcpt = bltcnxlpt;
                    372:     bltdpt = bltdnxlpt;
                    373:     blineb = (blineb << 1) | (blineb >> 15);
                    374:     if (--blt_info.vblitsize == 0) {
                    375:        bltstate = BLT_done;
                    376:     } else {
                    377:        bltstate = BLT_read;
                    378:     }
                    379: }
                    380: 
                    381: static void blit_init(void)
                    382: {
                    383:     blitlpos = 0;
1.1.1.3   root      384:     blt_info.blitzero = 1;
1.1       root      385:     blitline = bltcon1 & 1;
1.1.1.3   root      386:     blt_info.blitashift = bltcon0 >> 12;
1.1.1.2   root      387:     blt_info.blitdownashift = 16 - blt_info.blitashift;
                    388:     blt_info.blitbshift = bltcon1 >> 12;
                    389:     blt_info.blitdownbshift = 16 - blt_info.blitbshift;
1.1.1.3   root      390: 
1.1       root      391:     if (blitline) {
1.1.1.4   root      392:        if (blt_info.hblitsize != 2)
                    393:            write_log ("weird hblitsize in linemode: %d\n", blt_info.hblitsize);
                    394: 
1.1       root      395:        bltcnxlpt = bltcpt;
                    396:        bltdnxlpt = bltdpt;
                    397:        blitsing = bltcon1 & 0x2;
                    398:        blinea = blt_info.bltadat;
                    399:        blineb = (blt_info.bltbdat >> blt_info.blitbshift) | (blt_info.bltbdat << (16-blt_info.blitbshift));
                    400: #if 0
                    401:        if (blineb != 0xFFFF && blineb != 0)
1.1.1.11  root      402:            write_log ("%x %x %d %x\n", blineb, blt_info.bltbdat, blt_info.blitbshift, bltcon1);
1.1       root      403: #endif
1.1.1.3   root      404:        blitsign = bltcon1 & 0x40;
1.1       root      405:        blitonedot = 0;
                    406:     } else {
                    407:        blitfc = !!(bltcon1 & 0x4);
                    408:        blitife = bltcon1 & 0x8;
                    409:        blitfill = bltcon1 & 0x18;
                    410:        if ((bltcon1 & 0x18) == 0x18) {
                    411:            /* Digital "Trash" demo does this; others too. Apparently, no
                    412:             * negative effects. */
                    413:            static int warn = 1;
                    414:            if (warn)
1.1.1.3   root      415:                write_log ("warning: weird fill mode (further messages suppressed)\n");
1.1       root      416:            warn = 0;
                    417:        }
                    418:        blitdesc = bltcon1 & 0x2;
1.1.1.7   root      419:        if (blitfill && !blitdesc) {
                    420:            static int warn = 1;
                    421:            if (warn)
1.1.1.13  root      422:                write_log ("warning: blitter fill without desc (further messages suppressed)\n");
1.1.1.7   root      423:            warn = 0;
                    424:        }
1.1       root      425:     }
                    426: }
                    427: 
                    428: static void actually_do_blit(void)
                    429: {
                    430:     if (blitline) {
                    431:        do {
                    432:            blitter_read();
                    433:            blitter_line();
                    434:            blitter_write();
                    435:            blitter_nxline();
                    436:        } while (bltstate != BLT_done);
                    437:     } else {
1.1.1.15! root      438:        if (blitdesc)
        !           439:            blitter_dofast_desc();
        !           440:        else
        !           441:            blitter_dofast();
1.1       root      442:     }
1.1.1.2   root      443:     blitter_done_notify ();
1.1       root      444: }
                    445: 
                    446: void blitter_handler(void)
                    447: {
                    448:     if (!dmaen(DMA_BLITTER)) {
                    449:        eventtab[ev_blitter].active = 1;
1.1.1.9   root      450:        eventtab[ev_blitter].oldcycles = get_cycles ();
                    451:        eventtab[ev_blitter].evtime = 10 * CYCLE_UNIT + get_cycles (); /* wait a little */
1.1       root      452:        return; /* gotta come back later. */
                    453:     }
                    454:     actually_do_blit();
1.1.1.3   root      455: 
1.1       root      456:     INTREQ(0x8040);
                    457:     eventtab[ev_blitter].active = 0;
1.1.1.8   root      458:     unset_special (SPCFLAG_BLTNASTY);
1.1       root      459: }
                    460: 
1.1.1.12  root      461: static long int blit_cycles;
                    462: static long blit_firstline_cycles;
                    463: static long blit_first_cycle;
                    464: static int blit_last_cycle;
                    465: static uae_u8 *blit_diag;
1.1.1.3   root      466: 
1.1.1.12  root      467: void do_blitter(void)
                    468: {
                    469:     int ch = (bltcon0 & 0x0f00) >> 8;
                    470:     blit_diag = blit_cycle_diagram_start[ch];
1.1       root      471: 
1.1.1.12  root      472:     blit_firstline_cycles = blit_first_cycle = get_cycles ();
                    473:     blit_last_cycle = 0;
                    474:     if (!currprefs.immediate_blits) {
1.1       root      475:        if (!blitline) {
1.1.1.12  root      476:            blit_cycles = blit_diag[1];
                    477:            blit_firstline_cycles += blit_cycles * blt_info.hblitsize * CYCLE_UNIT;
1.1       root      478:            blit_cycles *= blt_info.vblitsize * blt_info.hblitsize;
1.1.1.12  root      479:        } else
1.1.1.13  root      480:             blit_cycles = 20; /* Desert Dream demo freezes if line draw is too fast */
1.1.1.3   root      481:     } else
1.1.1.2   root      482:        blit_cycles = 1;
                    483: 
                    484:     blit_init();
1.1.1.3   root      485: 
1.1.1.2   root      486:     eventtab[ev_blitter].active = 1;
1.1.1.9   root      487:     eventtab[ev_blitter].oldcycles = get_cycles ();
                    488:     eventtab[ev_blitter].evtime = blit_cycles * CYCLE_UNIT + get_cycles ();
1.1.1.2   root      489:     events_schedule();
1.1       root      490: 
1.1.1.8   root      491:     unset_special (SPCFLAG_BLTNASTY);
1.1.1.2   root      492:     if (dmaen(DMA_BLITPRI))
1.1.1.8   root      493:        set_special (SPCFLAG_BLTNASTY);
1.1.1.12  root      494: 
1.1       root      495: }
                    496: 
1.1.1.12  root      497: void maybe_blit (int modulo)
1.1       root      498: {
                    499:     static int warned = 0;
                    500:     if (bltstate == BLT_done)
                    501:        return;
1.1.1.3   root      502: 
1.1       root      503:     if (!warned) {
                    504:        warned = 1;
1.1.1.3   root      505:        write_log ("warning: Program does not wait for blitter\n");
1.1       root      506:     }
                    507:     if (!eventtab[ev_blitter].active)
1.1.1.12  root      508:        write_log ("FOO!!?\n");
                    509: 
                    510:     if (modulo && get_cycles() < blit_firstline_cycles)
                    511:        return;
1.1.1.8   root      512:     blitter_handler ();
1.1       root      513: }
1.1.1.12  root      514: 
                    515: int blitnasty (void)
                    516: {
                    517:     int cycles, ccnt;
                    518:     if (!(regs.spcflags & SPCFLAG_BLTNASTY))
                    519:        return 0;
                    520:     if (bltstate == BLT_done)
                    521:        return 0;
                    522:     if (!dmaen(DMA_BLITTER))
                    523:        return 0;
                    524:     cycles = (get_cycles () - blit_first_cycle) / CYCLE_UNIT;
                    525:     ccnt = 0;
                    526:     while (blit_last_cycle < cycles) {
                    527:        int c;
                    528:        if (blit_last_cycle < blit_diag[0])
                    529:            c = blit_diag[blit_last_cycle + 2];
                    530:        else
1.1.1.13  root      531:            c = blit_diag[((blit_last_cycle - blit_diag[0]) % blit_diag[1]) + 2 + blit_diag[0]];
1.1.1.12  root      532:        blit_last_cycle ++;
                    533:        if (!c)
                    534:            return 0;
                    535:        ccnt++;
                    536:     }
                    537:     return ccnt;
                    538: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.