4 // Original source by David Raingeard (Cal2)
5 // GCC/SDL port by Niels Wagenaar (Linux/WIN32) and Caz (BeOS)
6 // Extensive cleanups/fixes/rewrites by James Hammons
7 // (C) 2010 Underground Software
9 // JLH = James Hammons <jlhamm@acm.org>
12 // --- ---------- -------------------------------------------------------------
13 // JLH 01/16/2010 Created this log ;-)
28 //#define OP_DEBUG_BMP
30 #define BLEND_Y(dst, src) op_blend_y[(((uint16)dst<<8)) | ((uint16)(src))]
31 #define BLEND_CR(dst, src) op_blend_cr[(((uint16)dst)<<8) | ((uint16)(src))]
33 #define OBJECT_TYPE_BITMAP 0 // 000
34 #define OBJECT_TYPE_SCALE 1 // 001
35 #define OBJECT_TYPE_GPU 2 // 010
36 #define OBJECT_TYPE_BRANCH 3 // 011
37 #define OBJECT_TYPE_STOP 4 // 100
39 #define CONDITION_EQUAL 0
40 #define CONDITION_LESS_THAN 1
41 #define CONDITION_GREATER_THAN 2
42 #define CONDITION_OP_FLAG_SET 3
43 #define CONDITION_SECOND_HALF_LINE 4
45 #define OPFLAG_RELEASE 8 // Bus release bit
46 #define OPFLAG_TRANS 4 // Transparency bit
47 #define OPFLAG_RMW 2 // Read-Modify-Write bit
48 #define OPFLAG_REFLECT 1 // Horizontal mirror bit
50 // Private function prototypes
52 void OPProcessFixedBitmap(uint64 p0, uint64 p1, bool render);
53 void OPProcessScaledBitmap(uint64 p0, uint64 p1, uint64 p2, bool render);
54 void OPDiscoverObjects(uint32 address);
55 void OPDumpObjectList(void);
56 void DumpScaledObject(uint64 p0, uint64 p1, uint64 p2);
57 void DumpFixedObject(uint64 p0, uint64 p1);
58 void DumpBitmapCore(uint64 p0, uint64 p1);
59 uint64 OPLoadPhrase(uint32 offset);
61 // Local global variables
63 // Blend tables (64K each)
64 static uint8 op_blend_y[0x10000];
65 static uint8 op_blend_cr[0x10000];
66 // There may be a problem with this "RAM" overlapping (and thus being independent of)
67 // some of the regular TOM RAM...
68 //#warning objectp_ram is separated from TOM RAM--need to fix that!
69 //static uint8 objectp_ram[0x40]; // This is based at $F00000
70 uint8 objectp_running = 0;
71 //bool objectp_stop_reading_list;
73 static uint8 op_bitmap_bit_depth[8] = { 1, 2, 4, 8, 16, 24, 32, 0 };
74 //static uint32 op_bitmap_bit_size[8] =
75 // { (uint32)(0.125*65536), (uint32)(0.25*65536), (uint32)(0.5*65536), (uint32)(1*65536),
76 // (uint32)(2*65536), (uint32)(1*65536), (uint32)(1*65536), (uint32)(1*65536) };
77 static uint32 op_pointer;
79 int32 phraseWidthToPixels[8] = { 64, 32, 16, 8, 4, 2, 0, 0 };
83 // Object Processor initialization
87 // Here we calculate the saturating blend of a signed 4-bit value and an
88 // existing Cyan/Red value as well as a signed 8-bit value and an existing intensity...
89 // Note: CRY is 4 bits Cyan, 4 bits Red, 16 bits intensitY
90 for(int i=0; i<256*256; i++)
92 int y = (i >> 8) & 0xFF;
93 int dy = (int8)i; // Sign extend the Y index
94 int c1 = (i >> 8) & 0x0F;
95 int dc1 = (int8)(i << 4) >> 4; // Sign extend the R index
96 int c2 = (i >> 12) & 0x0F;
97 int dc2 = (int8)(i & 0xF0) >> 4; // Sign extend the C index
122 op_blend_cr[i] = (c2 << 4) | c1;
129 // Object Processor reset
133 // memset(objectp_ram, 0x00, 0x40);
137 static const char * opType[8] =
138 { "(BITMAP)", "(SCALED BITMAP)", "(GPU INT)", "(BRANCH)", "(STOP)", "???", "???", "???" };
139 static const char * ccType[8] =
140 { "\"==\"", "\"<\"", "\">\"", "(opflag set)", "(second half line)", "?", "?", "?" };
141 static uint32 object[8192];
142 static uint32 numberOfObjects;
143 //static uint32 objectLink[8192];
144 //static uint32 numberOfLinks;
148 //#warning "!!! Fix OL dump so that it follows links !!!"
149 // const char * opType[8] =
150 // { "(BITMAP)", "(SCALED BITMAP)", "(GPU INT)", "(BRANCH)", "(STOP)", "???", "???", "???" };
151 // const char * ccType[8] =
152 // { "\"==\"", "\"<\"", "\">\"", "(opflag set)", "(second half line)", "?", "?", "?" };
154 uint32 olp = OPGetListPointer();
155 WriteLog("\nOP: OLP = $%08X\n", olp);
156 WriteLog("OP: Phrase dump\n ----------\n");
159 for(uint32 i=0; i<0x100; i+=8)
161 uint32 hi = JaguarReadLong(olp + i, OP), lo = JaguarReadLong(olp + i + 4, OP);
162 WriteLog("\t%08X: %08X %08X %s", olp + i, hi, lo, opType[lo & 0x07]);
164 if ((lo & 0x07) == 3)
166 uint16 ypos = (lo >> 3) & 0x7FF;
167 uint8 cc = (lo >> 14) & 0x03;
168 uint32 link = ((hi << 11) | (lo >> 21)) & 0x3FFFF8;
169 WriteLog(" YPOS=%u, CC=%s, link=%08X", ypos, ccType[cc], link);
174 if ((lo & 0x07) == 0)
175 DumpFixedObject(OPLoadPhrase(olp+i), OPLoadPhrase(olp+i+8));
177 if ((lo & 0x07) == 1)
178 DumpScaledObject(OPLoadPhrase(olp+i), OPLoadPhrase(olp+i+8), OPLoadPhrase(olp+i+16));
184 OPDiscoverObjects(olp);
189 void OPDiscoverObjects(uint32 address)
191 // Check to see if we've already seen this object
192 for(uint32 i=0; i<numberOfObjects; i++)
194 if (address == object[i])
198 // Store the object...
199 object[numberOfObjects++] = address;
200 uint8 objectType = 0;
204 uint32 hi = JaguarReadLong(address + 0, OP);
205 uint32 lo = JaguarReadLong(address + 4, OP);
206 objectType = lo & 0x07;
207 uint32 link = ((hi << 11) | (lo >> 21)) & 0x3FFFF8;
211 uint16 ypos = (lo >> 3) & 0x7FF;
212 uint8 cc = (lo >> 14) & 0x07; // Proper # of bits == 3
214 // Recursion needed to follow all links!
215 OPDiscoverObjects(address + 8);
218 if (address == link) // Ruh roh...
220 // Runaway recursive link is bad!
226 // Check to see if we've already seen this object, and add it if not
227 bool seenObject = false;
229 for(uint32 i=0; i<numberOfObjects; i++)
231 if (address == object[i])
239 object[numberOfObjects++] = address;
241 while (objectType != 4);
244 void OPDumpObjectList(void)
246 for(uint32 i=0; i<numberOfObjects; i++)
248 uint32 address = object[i];
250 uint32 hi = JaguarReadLong(address + 0, OP);
251 uint32 lo = JaguarReadLong(address + 4, OP);
252 uint8 objectType = lo & 0x07;
253 uint32 link = ((hi << 11) | (lo >> 21)) & 0x3FFFF8;
254 WriteLog("%08X: %08X %08X %s", address, hi, lo, opType[objectType]);
258 uint16 ypos = (lo >> 3) & 0x7FF;
259 uint8 cc = (lo >> 14) & 0x07; // Proper # of bits == 3
260 WriteLog(" YPOS=%u, CC=%s, link=$%08X", ypos, ccType[cc], link);
266 DumpFixedObject(OPLoadPhrase(address + 0), OPLoadPhrase(address + 8));
269 DumpScaledObject(OPLoadPhrase(address + 0), OPLoadPhrase(address + 8),
270 OPLoadPhrase(address + 16));
272 if (address == link) // Ruh roh...
274 // Runaway recursive link is bad!
275 WriteLog("***** SELF REFERENTIAL LINK *****\n\n");
283 // Object Processor memory access
284 // Memory range: F00010 - F00027
286 // F00010-F00017 R xxxxxxxx xxxxxxxx OB - current object code from the graphics processor
287 // F00020-F00023 W xxxxxxxx xxxxxxxx OLP - start of the object list
288 // F00026 W -------- -------x OBF - object processor flag
292 uint8 OPReadByte(uint32 offset, uint32 who/*=UNKNOWN*/)
295 return objectp_ram[offset];
298 uint16 OPReadWord(uint32 offset, uint32 who/*=UNKNOWN*/)
301 return GET16(objectp_ram, offset);
304 void OPWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/)
307 objectp_ram[offset] = data;
310 void OPWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/)
313 SET16(objectp_ram, offset, data);
315 /*if (offset == 0x20)
316 WriteLog("OP: Setting lo list pointer: %04X\n", data);
318 WriteLog("OP: Setting hi list pointer: %04X\n", data);//*/
322 uint32 OPGetListPointer(void)
324 // Note: This register is LO / HI WORD, hence the funky look of this...
325 return GET16(tomRam8, 0x20) | (GET16(tomRam8, 0x22) << 16);
328 // This is WRONG, since the OBF is only 16 bits wide!!! [FIXED]
330 uint32 OPGetStatusRegister(void)
332 return GET16(tomRam8, 0x26);
335 // This is WRONG, since the OBF is only 16 bits wide!!! [FIXED]
337 void OPSetStatusRegister(uint32 data)
339 tomRam8[0x26] = (data & 0x0000FF00) >> 8;
340 tomRam8[0x27] |= (data & 0xFE);
343 void OPSetCurrentObject(uint64 object)
345 //Not sure this is right... Wouldn't it just be stored 64 bit BE?
346 // Stored as least significant 32 bits first, ms32 last in big endian
347 /* objectp_ram[0x13] = object & 0xFF; object >>= 8;
348 objectp_ram[0x12] = object & 0xFF; object >>= 8;
349 objectp_ram[0x11] = object & 0xFF; object >>= 8;
350 objectp_ram[0x10] = object & 0xFF; object >>= 8;
352 objectp_ram[0x17] = object & 0xFF; object >>= 8;
353 objectp_ram[0x16] = object & 0xFF; object >>= 8;
354 objectp_ram[0x15] = object & 0xFF; object >>= 8;
355 objectp_ram[0x14] = object & 0xFF;*/
356 // Let's try regular good old big endian...
357 tomRam8[0x17] = object & 0xFF; object >>= 8;
358 tomRam8[0x16] = object & 0xFF; object >>= 8;
359 tomRam8[0x15] = object & 0xFF; object >>= 8;
360 tomRam8[0x14] = object & 0xFF; object >>= 8;
362 tomRam8[0x13] = object & 0xFF; object >>= 8;
363 tomRam8[0x12] = object & 0xFF; object >>= 8;
364 tomRam8[0x11] = object & 0xFF; object >>= 8;
365 tomRam8[0x10] = object & 0xFF;
368 uint64 OPLoadPhrase(uint32 offset)
370 offset &= ~0x07; // 8 byte alignment
371 return ((uint64)JaguarReadLong(offset, OP) << 32) | (uint64)JaguarReadLong(offset+4, OP);
374 void OPStorePhrase(uint32 offset, uint64 p)
376 offset &= ~0x07; // 8 byte alignment
377 JaguarWriteLong(offset, p >> 32, OP);
378 JaguarWriteLong(offset + 4, p & 0xFFFFFFFF, OP);
382 // Debugging routines
384 void DumpScaledObject(uint64 p0, uint64 p1, uint64 p2)
386 WriteLog(" %08X %08X\n", (uint32)(p1>>32), (uint32)(p1&0xFFFFFFFF));
387 WriteLog(" %08X %08X\n", (uint32)(p2>>32), (uint32)(p2&0xFFFFFFFF));
388 DumpBitmapCore(p0, p1);
389 uint32 hscale = p2 & 0xFF;
390 uint32 vscale = (p2 >> 8) & 0xFF;
391 uint32 remainder = (p2 >> 16) & 0xFF;
392 WriteLog(" [hsc: %02X, vsc: %02X, rem: %02X]\n", hscale, vscale, remainder);
395 void DumpFixedObject(uint64 p0, uint64 p1)
397 WriteLog(" %08X %08X\n", (uint32)(p1>>32), (uint32)(p1&0xFFFFFFFF));
398 DumpBitmapCore(p0, p1);
401 void DumpBitmapCore(uint64 p0, uint64 p1)
403 uint32 bdMultiplier[8] = { 64, 32, 16, 8, 4, 2, 1, 1 };
404 uint8 bitdepth = (p1 >> 12) & 0x07;
405 //WAS: int16 ypos = ((p0 >> 3) & 0x3FF); // ??? What if not interlaced (/2)?
406 int16 ypos = ((p0 >> 3) & 0x7FF); // ??? What if not interlaced (/2)?
407 int32 xpos = p1 & 0xFFF;
408 xpos = (xpos & 0x800 ? xpos | 0xFFFFF000 : xpos); // Sign extend that mutha!
409 uint32 iwidth = ((p1 >> 28) & 0x3FF);
410 uint32 dwidth = ((p1 >> 18) & 0x3FF); // Unsigned!
411 uint16 height = ((p0 >> 14) & 0x3FF);
412 uint32 link = ((p0 >> 24) & 0x7FFFF) << 3;
413 uint32 ptr = ((p0 >> 43) & 0x1FFFFF) << 3;
414 uint32 firstPix = (p1 >> 49) & 0x3F;
415 uint8 flags = (p1 >> 45) & 0x0F;
416 uint8 idx = (p1 >> 38) & 0x7F;
417 uint32 pitch = (p1 >> 15) & 0x07;
418 WriteLog(" [%u x %u @ (%i, %u) (iw:%u, dw:%u) (%u bpp), l:%08X, p:%08X fp:%02X, fl:%s%s%s%s, idx:%02X, pt:%02X]\n",
419 iwidth * bdMultiplier[bitdepth],
420 height, xpos, ypos, iwidth, dwidth, op_bitmap_bit_depth[bitdepth], link,
421 ptr, firstPix, (flags&OPFLAG_REFLECT ? "REFLECT " : ""),
422 (flags&OPFLAG_RMW ? "RMW " : ""), (flags&OPFLAG_TRANS ? "TRANS " : ""),
423 (flags&OPFLAG_RELEASE ? "RELEASE" : ""), idx, pitch);
427 // Object Processor main routine
429 #warning "Need to fix this so that when an GPU object IRQ happens, we can pick up OP processing where we left off. !!! FIX !!!"
430 void OPProcessList(int halfline, bool render)
432 #warning "!!! NEED TO HANDLE MULTIPLE FIELDS PROPERLY !!!
433 // We ignore them, for now; not good
436 extern int op_start_log;
437 // char * condition_to_str[8] =
438 // { "==", "<", ">", "(opflag set)", "(second half line)", "?", "?", "?" };
440 op_pointer = OPGetListPointer();
442 // objectp_stop_reading_list = false;
444 //WriteLog("OP: Processing line #%u (OLP=%08X)...\n", halfline, op_pointer);
447 // *** BEGIN OP PROCESSOR TESTING ONLY ***
448 extern bool interactiveMode;
450 extern int objectPtr;
452 int bitmapCounter = 0;
453 // *** END OP PROCESSOR TESTING ONLY ***
455 uint32 opCyclesToRun = 30000; // This is a pulled-out-of-the-air value (will need to be fixed, obviously!)
457 // if (op_pointer) WriteLog(" new op list at 0x%.8x halfline %i\n",op_pointer,halfline);
460 // *** BEGIN OP PROCESSOR TESTING ONLY ***
461 if (interactiveMode && bitmapCounter == objectPtr)
465 // *** END OP PROCESSOR TESTING ONLY ***
466 // if (objectp_stop_reading_list)
469 uint64 p0 = OPLoadPhrase(op_pointer);
471 //WriteLog("\t%08X type %i\n", op_pointer, (uint8)p0 & 0x07);
474 if (halfline == TOMGetVDB() && op_start_log)
475 //if (halfline == 215 && op_start_log)
476 //if (halfline == 28 && op_start_log)
479 WriteLog("%08X --> phrase %08X %08X", op_pointer - 8, (int)(p0>>32), (int)(p0&0xFFFFFFFF));
480 if ((p0 & 0x07) == OBJECT_TYPE_BITMAP)
482 WriteLog(" (BITMAP) ");
483 uint64 p1 = OPLoadPhrase(op_pointer);
484 WriteLog("\n%08X --> phrase %08X %08X ", op_pointer, (int)(p1>>32), (int)(p1&0xFFFFFFFF));
485 uint8 bitdepth = (p1 >> 12) & 0x07;
486 //WAS: int16 ypos = ((p0 >> 3) & 0x3FF); // ??? What if not interlaced (/2)?
487 int16 ypos = ((p0 >> 3) & 0x7FF); // ??? What if not interlaced (/2)?
488 int32 xpos = p1 & 0xFFF;
489 xpos = (xpos & 0x800 ? xpos | 0xFFFFF000 : xpos);
490 uint32 iwidth = ((p1 >> 28) & 0x3FF);
491 uint32 dwidth = ((p1 >> 18) & 0x3FF); // Unsigned!
492 uint16 height = ((p0 >> 14) & 0x3FF);
493 uint32 link = ((p0 >> 24) & 0x7FFFF) << 3;
494 uint32 ptr = ((p0 >> 43) & 0x1FFFFF) << 3;
495 uint32 firstPix = (p1 >> 49) & 0x3F;
496 uint8 flags = (p1 >> 45) & 0x0F;
497 uint8 idx = (p1 >> 38) & 0x7F;
498 uint32 pitch = (p1 >> 15) & 0x07;
499 WriteLog("\n [%u (%u) x %u @ (%i, %u) (%u bpp), l: %08X, p: %08X fp: %02X, fl:%s%s%s%s, idx:%02X, pt:%02X]\n",
500 iwidth, dwidth, height, xpos, ypos, op_bitmap_bit_depth[bitdepth], link, ptr, firstPix, (flags&OPFLAG_REFLECT ? "REFLECT " : ""), (flags&OPFLAG_RMW ? "RMW " : ""), (flags&OPFLAG_TRANS ? "TRANS " : ""), (flags&OPFLAG_RELEASE ? "RELEASE" : ""), idx, pitch);
502 if ((p0 & 0x07) == OBJECT_TYPE_SCALE)
504 WriteLog(" (SCALED BITMAP)");
505 uint64 p1 = OPLoadPhrase(op_pointer), p2 = OPLoadPhrase(op_pointer+8);
506 WriteLog("\n%08X --> phrase %08X %08X ", op_pointer, (int)(p1>>32), (int)(p1&0xFFFFFFFF));
507 WriteLog("\n%08X --> phrase %08X %08X ", op_pointer+8, (int)(p2>>32), (int)(p2&0xFFFFFFFF));
508 uint8 bitdepth = (p1 >> 12) & 0x07;
509 //WAS: int16 ypos = ((p0 >> 3) & 0x3FF); // ??? What if not interlaced (/2)?
510 int16 ypos = ((p0 >> 3) & 0x7FF); // ??? What if not interlaced (/2)?
511 int32 xpos = p1 & 0xFFF;
512 xpos = (xpos & 0x800 ? xpos | 0xFFFFF000 : xpos);
513 uint32 iwidth = ((p1 >> 28) & 0x3FF);
514 uint32 dwidth = ((p1 >> 18) & 0x3FF); // Unsigned!
515 uint16 height = ((p0 >> 14) & 0x3FF);
516 uint32 link = ((p0 >> 24) & 0x7FFFF) << 3;
517 uint32 ptr = ((p0 >> 43) & 0x1FFFFF) << 3;
518 uint32 firstPix = (p1 >> 49) & 0x3F;
519 uint8 flags = (p1 >> 45) & 0x0F;
520 uint8 idx = (p1 >> 38) & 0x7F;
521 uint32 pitch = (p1 >> 15) & 0x07;
522 WriteLog("\n [%u (%u) x %u @ (%i, %u) (%u bpp), l: %08X, p: %08X fp: %02X, fl:%s%s%s%s, idx:%02X, pt:%02X]\n",
523 iwidth, dwidth, height, xpos, ypos, op_bitmap_bit_depth[bitdepth], link, ptr, firstPix, (flags&OPFLAG_REFLECT ? "REFLECT " : ""), (flags&OPFLAG_RMW ? "RMW " : ""), (flags&OPFLAG_TRANS ? "TRANS " : ""), (flags&OPFLAG_RELEASE ? "RELEASE" : ""), idx, pitch);
524 uint32 hscale = p2 & 0xFF;
525 uint32 vscale = (p2 >> 8) & 0xFF;
526 uint32 remainder = (p2 >> 16) & 0xFF;
527 WriteLog(" [hsc: %02X, vsc: %02X, rem: %02X]\n", hscale, vscale, remainder);
529 if ((p0 & 0x07) == OBJECT_TYPE_GPU)
530 WriteLog(" (GPU)\n");
531 if ((p0 & 0x07) == OBJECT_TYPE_BRANCH)
533 WriteLog(" (BRANCH)\n");
534 uint8 * jaguarMainRam = GetRamPtr();
535 WriteLog("[RAM] --> ");
536 for(int k=0; k<8; k++)
537 WriteLog("%02X ", jaguarMainRam[op_pointer-8 + k]);
540 if ((p0 & 0x07) == OBJECT_TYPE_STOP)
541 WriteLog(" --> List end\n\n");
545 switch ((uint8)p0 & 0x07)
547 case OBJECT_TYPE_BITMAP:
549 //WAS: uint16 ypos = (p0 >> 3) & 0x3FF;
550 uint16 ypos = (p0 >> 3) & 0x7FF;
551 // This is only theory implied by Rayman...!
552 // It seems that if the YPOS is zero, then bump the YPOS value so that it coincides with
553 // the VDB value. With interlacing, this would be slightly more tricky.
554 // There's probably another bit somewhere that enables this mode--but so far, doesn't seem
555 // to affect any other game in a negative way (that I've seen).
556 // Either that, or it's an undocumented bug...
558 //No, the reason this was needed is that the OP code before was wrong. Any value
559 //less than VDB will get written to the top line of the display!
561 // Not so sure... Let's see what happens here...
564 ypos = TOMReadWord(0xF00046, OP) / 2; // Get the VDB value
566 // Actually, no. Any item less than VDB will get only the lines that hang over VDB displayed.
567 // Actually, this is incorrect. It seems that VDB value is wrong somewhere and that's
568 // what's causing things to fuck up. Still no idea why.
570 uint32 height = (p0 & 0xFFC000) >> 14;
571 uint32 oldOPP = op_pointer - 8;
572 // *** BEGIN OP PROCESSOR TESTING ONLY ***
573 if (inhibit && op_start_log)
574 WriteLog("!!! ^^^ This object is INHIBITED! ^^^ !!!\n");
576 if (!inhibit) // For OP testing only!
577 // *** END OP PROCESSOR TESTING ONLY ***
578 if (halfline >= ypos && height > 0)
580 uint64 p1 = OPLoadPhrase(op_pointer);
582 //WriteLog("OP: Writing halfline %d with ypos == %d...\n", halfline, ypos);
583 //WriteLog("--> Writing %u BPP bitmap...\n", op_bitmap_bit_depth[(p1 >> 12) & 0x07]);
584 // OPProcessFixedBitmap(halfline, p0, p1, render);
585 OPProcessFixedBitmap(p0, p1, render);
589 //???Does this really happen??? Doesn't seem to work if you do this...!
590 //Probably not. Must be a bug in the documentation...!
591 // uint32 link = (p0 & 0x7FFFF000000) >> 21;
592 // SET16(tom_ram_8, 0x20, link & 0xFFFF); // OLP
593 // SET16(tom_ram_8, 0x22, link >> 16);
594 /* uint32 height = (p0 & 0xFFC000) >> 14;
597 // NOTE: Would subtract 2 if in interlaced mode...!
598 // uint64 height = ((p0 & 0xFFC000) - 0x4000) & 0xFFC000;
602 uint64 data = (p0 & 0xFFFFF80000000000LL) >> 40;
603 uint64 dwidth = (p1 & 0xFFC0000) >> 15;
606 p0 &= ~0xFFFFF80000FFC000LL; // Mask out old data...
607 p0 |= (uint64)height << 14;
609 OPStorePhrase(oldOPP, p0);
611 //WriteLog("\t\tOld OP: %08X -> ", op_pointer);
612 //Temp, for testing...
613 //No doubt, this type of check will break all kinds of stuff... !!! FIX !!!
614 //And it does! !!! FIX !!!
615 //Let's remove this "fix" since it screws up more than it fixes.
616 /* if (op_pointer > ((p0 & 0x000007FFFF000000LL) >> 21))
619 op_pointer = (p0 & 0x000007FFFF000000LL) >> 21;
620 //WriteLog("New OP: %08X\n", op_pointer);
623 case OBJECT_TYPE_SCALE:
625 //WAS: uint16 ypos = (p0 >> 3) & 0x3FF;
626 uint16 ypos = (p0 >> 3) & 0x7FF;
627 uint32 height = (p0 & 0xFFC000) >> 14;
628 uint32 oldOPP = op_pointer - 8;
629 //WriteLog("OP: Scaled Object (ypos=%04X, height=%04X", ypos, height);
630 // *** BEGIN OP PROCESSOR TESTING ONLY ***
631 if (inhibit && op_start_log)
633 WriteLog("!!! ^^^ This object is INHIBITED! ^^^ !!! (halfline=%u, ypos=%u, height=%u)\n", halfline, ypos, height);
634 DumpScaledObject(p0, OPLoadPhrase(op_pointer), OPLoadPhrase(op_pointer+8));
637 if (!inhibit) // For OP testing only!
638 // *** END OP PROCESSOR TESTING ONLY ***
639 if (halfline >= ypos && height > 0)
641 uint64 p1 = OPLoadPhrase(op_pointer);
643 uint64 p2 = OPLoadPhrase(op_pointer);
645 //WriteLog("OP: %08X (%d) %08X%08X %08X%08X %08X%08X\n", oldOPP, halfline, (uint32)(p0>>32), (uint32)(p0&0xFFFFFFFF), (uint32)(p1>>32), (uint32)(p1&0xFFFFFFFF), (uint32)(p2>>32), (uint32)(p2&0xFFFFFFFF));
646 OPProcessScaledBitmap(p0, p1, p2, render);
650 uint16 remainder = (p2 >> 16) & 0xFF;//, vscale = p2 >> 8;
651 uint8 /*remainder = p2 >> 16,*/ vscale = p2 >> 8;
652 //Actually, we should skip this object if it has a vscale of zero.
653 //Or do we? Not sure... Atari Karts has a few lines that look like:
655 //000E8268 --> phrase 00010000 7000B00D
656 // [7 (0) x 1 @ (13, 0) (8 bpp), l: 000E82A0, p: 000E0FC0 fp: 00, fl:RELEASE, idx:00, pt:01]
657 // [hsc: 9A, vsc: 00, rem: 00]
658 // Could it be the vscale is overridden if the DWIDTH is zero? Hmm...
659 //WriteLog("OP: Scaled bitmap processing (rem=%02X, vscale=%02X)...\n", remainder, vscale);//*/
662 vscale = 0x20; // OP bug??? Nope, it isn't...! Or is it?
664 //extern int start_logging;
666 // WriteLog("--> Returned from scaled bitmap processing (rem=%02X, vscale=%02X)...\n", remainder, vscale);//*/
668 //--> Returned from scaled bitmap processing (rem=20, vscale=80)...
669 //There are other problems here, it looks like...
671 //About to execute OP (508)...
673 OP: Scaled bitmap 4x? 4bpp at 38,? hscale=7C fpix=0 data=00075E28 pitch 1 hflipped=no dwidth=? (linked to 00071118) Transluency=no
674 --> Returned from scaled bitmap processing (rem=50, vscale=7C)...
675 OP: Scaled bitmap 4x? 4bpp at 38,? hscale=7C fpix=0 data=00075E28 pitch 1 hflipped=no dwidth=? (linked to 00071118) Transluency=no
676 --> Returned from scaled bitmap processing (rem=30, vscale=7C)...
677 OP: Scaled bitmap 4x? 4bpp at 38,? hscale=7C fpix=0 data=00075E28 pitch 1 hflipped=no dwidth=? (linked to 00071118) Transluency=no
678 --> Returned from scaled bitmap processing (rem=10, vscale=7C)...
679 OP: Scaled bitmap 4x? 4bpp at 36,? hscale=7E fpix=0 data=000756A8 pitch 1 hflipped=no dwidth=? (linked to 00073058) Transluency=no
680 --> Returned from scaled bitmap processing (rem=00, vscale=7E)...
681 OP: Scaled bitmap 4x? 4bpp at 34,? hscale=80 fpix=0 data=000756C8 pitch 1 hflipped=no dwidth=? (linked to 00073078) Transluency=no
682 --> Returned from scaled bitmap processing (rem=00, vscale=80)...
683 OP: Scaled bitmap 4x? 4bpp at 36,? hscale=7E fpix=0 data=000756C8 pitch 1 hflipped=no dwidth=? (linked to 00073058) Transluency=no
684 --> Returned from scaled bitmap processing (rem=5E, vscale=7E)...
685 OP: Scaled bitmap 4x? 4bpp at 34,? hscale=80 fpix=0 data=000756E8 pitch 1 hflipped=no dwidth=? (linked to 00073078) Transluency=no
686 --> Returned from scaled bitmap processing (rem=60, vscale=80)...
687 OP: Scaled bitmap 4x? 4bpp at 36,? hscale=7E fpix=0 data=000756C8 pitch 1 hflipped=no dwidth=? (linked to 00073058) Transluency=no
688 --> Returned from scaled bitmap processing (rem=3E, vscale=7E)...
689 OP: Scaled bitmap 4x? 4bpp at 34,? hscale=80 fpix=0 data=000756E8 pitch 1 hflipped=no dwidth=? (linked to 00073078) Transluency=no
690 --> Returned from scaled bitmap processing (rem=40, vscale=80)...
691 OP: Scaled bitmap 4x? 4bpp at 36,? hscale=7E fpix=0 data=000756C8 pitch 1 hflipped=no dwidth=? (linked to 00073058) Transluency=no
692 --> Returned from scaled bitmap processing (rem=1E, vscale=7E)...
693 OP: Scaled bitmap 4x? 4bpp at 34,? hscale=80 fpix=0 data=000756E8 pitch 1 hflipped=no dwidth=? (linked to 00073078) Transluency=no
694 --> Returned from scaled bitmap processing (rem=20, vscale=80)...
696 //Here's another problem:
697 // [hsc: 20, vsc: 20, rem: 00]
698 // Since we're not checking for $E0 (but that's what we get from the above), we end
699 // up repeating this halfline unnecessarily... !!! FIX !!! [DONE, but... still not quite
700 // right. Either that, or the Accolade team that wrote Bubsy screwed up royal.]
701 //Also note: $E0 = 7.0 which IS a legal vscale value...
703 // if (remainder & 0x80) // I.e., it's negative
704 // if ((remainder & 0x80) || remainder == 0) // I.e., it's <= 0
705 // if ((remainder - 1) >= 0xE0) // I.e., it's <= 0
706 // if ((remainder >= 0xE1) || remainder == 0)// I.e., it's <= 0
707 // if ((remainder >= 0xE1 && remainder <= 0xFF) || remainder == 0)// I.e., it's <= 0
708 // if (remainder <= 0x20) // I.e., it's <= 1.0
709 // I.e., it's < 1.0f -> means it'll go negative when we subtract 1.0f.
710 if (remainder < 0x20)
712 uint64 data = (p0 & 0xFFFFF80000000000LL) >> 40;
713 uint64 dwidth = (p1 & 0xFFC0000) >> 15;
715 // while (remainder & 0x80)
716 // while ((remainder & 0x80) || remainder == 0)
717 // while ((remainder - 1) >= 0xE0)
718 // while ((remainder >= 0xE1) || remainder == 0)
719 // while ((remainder >= 0xE1 && remainder <= 0xFF) || remainder == 0)
720 // while (remainder <= 0x20)
721 while (remainder < 0x20)
731 p0 &= ~0xFFFFF80000FFC000LL; // Mask out old data...
732 p0 |= (uint64)height << 14;
734 OPStorePhrase(oldOPP, p0);
737 remainder -= 0x20; // 1.0f in [3.5] fixed point format
740 // WriteLog("--> Finished writebacks...\n");//*/
742 //WriteLog(" [%08X%08X -> ", (uint32)(p2>>32), (uint32)(p2&0xFFFFFFFF));
743 p2 &= ~0x0000000000FF0000LL;
744 p2 |= (uint64)remainder << 16;
745 //WriteLog("%08X%08X]\n", (uint32)(p2>>32), (uint32)(p2&0xFFFFFFFF));
746 OPStorePhrase(oldOPP + 16, p2);
747 //remainder = (uint8)(p2 >> 16), vscale = (uint8)(p2 >> 8);
748 //WriteLog(" [after]: rem=%02X, vscale=%02X\n", remainder, vscale);
751 op_pointer = (p0 & 0x000007FFFF000000LL) >> 21;
754 case OBJECT_TYPE_GPU:
756 //WriteLog("OP: Asserting GPU IRQ #3...\n");
757 #warning "Need to fix OP GPU IRQ handling! !!! FIX !!!"
758 OPSetCurrentObject(p0);
759 GPUSetIRQLine(3, ASSERT_LINE);
760 //Also, OP processing is suspended from this point until OBF (F00026) is written to...
763 //OPSuspendedByGPU = true;
764 //Dunno if the OP keeps processing from where it was interrupted, or if it just continues
765 //on the next halfline...
766 // --> It continues from where it was interrupted! !!! FIX !!!
769 case OBJECT_TYPE_BRANCH:
771 uint16 ypos = (p0 >> 3) & 0x7FF;
772 // NOTE: The JTRM sez there are only 2 bits used for the CC, but lists *five*
773 // conditions! Need at least one more bit for that! :-P
774 #warning "!!! Possibly bad CC handling in OP (missing 1 bit) !!!"
775 uint8 cc = (p0 >> 14) & 0x03;
776 uint32 link = (p0 >> 21) & 0x3FFFF8;
778 // if ((ypos!=507)&&(ypos!=25))
779 // WriteLog("\t%i%s%i link=0x%.8x\n",halfline,condition_to_str[cc],ypos>>1,link);
782 case CONDITION_EQUAL:
783 if (TOMReadWord(0xF00006, OP) == ypos || ypos == 0x7FF)
786 case CONDITION_LESS_THAN:
787 if (TOMReadWord(0xF00006, OP) < ypos)
790 case CONDITION_GREATER_THAN:
791 if (TOMReadWord(0xF00006, OP) > ypos)
794 case CONDITION_OP_FLAG_SET:
795 if (OPGetStatusRegister() & 0x01)
798 case CONDITION_SECOND_HALF_LINE:
799 //Here's the ASIC code:
800 // ND4(cctrue5, newheight[2], heightl[1], heightl[0], hcb[10]);
801 //which means, do the link if bit 10 of HC is set...
803 // This basically means branch if bit 10 of HC is set
804 #warning "Unhandled condition code causes emulator to crash... !!! FIX !!!"
805 WriteLog("OP: Unexpected CONDITION_SECOND_HALF_LINE in BRANCH object\nOP: shutting down!\n");
810 // Basically, if you do this, the OP does nothing. :-)
811 WriteLog("OP: Unimplemented branch condition %i\n", cc);
815 case OBJECT_TYPE_STOP:
819 //WriteLog("OP: --> STOP\n");
820 // op_set_status_register(((p0>>3) & 0xFFFFFFFF));
821 //This seems more likely...
822 OPSetCurrentObject(p0);
826 // We need to check whether these interrupts are enabled or not, THEN
827 // set an IRQ + pending flag if necessary...
828 if (TOMIRQEnabled(IRQ_OPFLAG))
830 TOMSetPendingObjectInt();
831 m68k_set_irq(2); // Cause a 68K IPL 2 to occur...
839 WriteLog("op: unknown object type %i\n", ((uint8)p0 & 0x07));
843 // Here is a little sanity check to keep the OP from locking up the machine
844 // when fed bad data. Better would be to count how many actual cycles it used
845 // and bail out/reenter to properly simulate an overloaded OP... !!! FIX !!!
846 #warning "Better would be to count how many actual cycles it used and bail out/reenter to properly simulate an overloaded OP... !!! FIX !!!"
855 // Store fixed size bitmap in line buffer
857 void OPProcessFixedBitmap(uint64 p0, uint64 p1, bool render)
859 // Need to make sure that when writing that it stays within the line buffer...
860 // LBUF ($F01800 - $F01D9E) 360 x 32-bit RAM
861 uint8 depth = (p1 >> 12) & 0x07; // Color depth of image
862 int32 xpos = ((int16)((p1 << 4) & 0xFFFF)) >> 4;// Image xpos in LBUF
863 uint32 iwidth = (p1 >> 28) & 0x3FF; // Image width in *phrases*
864 uint32 data = (p0 >> 40) & 0xFFFFF8; // Pixel data address
865 //#ifdef OP_DEBUG_BMP
866 uint32 firstPix = (p1 >> 49) & 0x3F;
867 // "The LSB is significant only for scaled objects..." -JTRM
868 // "In 1 BPP mode, all five bits are significant. In 2 BPP mode, the top four are significant..."
871 // We can ignore the RELEASE (high order) bit for now--probably forever...!
872 // uint8 flags = (p1 >> 45) & 0x0F; // REFLECT, RMW, TRANS, RELEASE
873 //Optimize: break these out to their own BOOL values
874 uint8 flags = (p1 >> 45) & 0x07; // REFLECT (0), RMW (1), TRANS (2)
875 bool flagREFLECT = (flags & OPFLAG_REFLECT ? true : false),
876 flagRMW = (flags & OPFLAG_RMW ? true : false),
877 flagTRANS = (flags & OPFLAG_TRANS ? true : false);
878 // "For images with 1 to 4 bits/pixel the top 7 to 4 bits of the index
879 // provide the most significant bits of the palette address."
880 uint8 index = (p1 >> 37) & 0xFE; // CLUT index offset (upper pix, 1-4 bpp)
881 uint32 pitch = (p1 >> 15) & 0x07; // Phrase pitch
882 pitch <<= 3; // Optimization: Multiply pitch by 8
884 // int16 scanlineWidth = tom_getVideoModeWidth();
885 uint8 * tomRam8 = TOMGetRamPointer();
886 uint8 * paletteRAM = &tomRam8[0x400];
887 // This is OK as long as it's used correctly: For 16-bit RAM to RAM direct copies--NOT
888 // for use when using endian-corrected data (i.e., any of the *_word_read functions!)
889 uint16 * paletteRAM16 = (uint16 *)paletteRAM;
891 // WriteLog("bitmap %ix? %ibpp at %i,? firstpix=? data=0x%.8x pitch %i hflipped=%s dwidth=? (linked to ?) RMW=%s Tranparent=%s\n",
892 // iwidth, op_bitmap_bit_depth[bitdepth], xpos, ptr, pitch, (flags&OPFLAG_REFLECT ? "yes" : "no"), (flags&OPFLAG_RMW ? "yes" : "no"), (flags&OPFLAG_TRANS ? "yes" : "no"));
894 // Is it OK to have a 0 for the data width??? (i.e., undocumented?)
895 // Seems to be... Seems that dwidth *can* be zero (i.e., reuse same line) as well.
896 // Pitch == 0 is OK too...
897 // if (!render || op_pointer == 0 || ptr == 0 || pitch == 0)
898 //I'm not convinced that we need to concern ourselves with data & op_pointer here either!
899 if (!render || iwidth == 0)
902 //OK, so we know the position in the line buffer is correct. It's the clipping in
903 //24bpp mode that's wrong!
905 //This is a total kludge, based upon the fact that 24BPP mode puts *4* bytes
906 //into the line buffer for each pixel.
907 if (depth == 5) // i.e., 24bpp mode...
908 xpos >>= 1; // Cut it in half...
911 //#define OP_DEBUG_BMP
912 //#ifdef OP_DEBUG_BMP
913 // WriteLog("bitmap %ix%i %ibpp at %i,%i firstpix=%i data=0x%.8x pitch %i hflipped=%s dwidth=%i (linked to 0x%.8x) Transluency=%s\n",
914 // iwidth, height, op_bitmap_bit_depth[bitdepth], xpos, ypos, firstPix, ptr, pitch, (flags&OPFLAG_REFLECT ? "yes" : "no"), dwidth, op_pointer, (flags&OPFLAG_RMW ? "yes" : "no"));
917 // int32 leftMargin = xpos, rightMargin = (xpos + (phraseWidthToPixels[depth] * iwidth)) - 1;
918 int32 startPos = xpos, endPos = xpos +
919 (!flagREFLECT ? (phraseWidthToPixels[depth] * iwidth) - 1
920 : -((phraseWidthToPixels[depth] * iwidth) + 1));
921 uint32 clippedWidth = 0, phraseClippedWidth = 0, dataClippedWidth = 0;//, phrasePixel = 0;
922 bool in24BPPMode = (((GET16(tomRam8, 0x0028) >> 1) & 0x03) == 1 ? true : false); // VMODE
923 // Not sure if this is Jaguar Two only location or what...
924 // From the docs, it is... If we want to limit here we should think of something else.
925 // int32 limit = GET16(tom_ram_8, 0x0008); // LIMIT
926 // int32 limit = 720;
927 // int32 lbufWidth = (!in24BPPMode ? limit - 1 : (limit / 2) - 1); // Zero based limit...
928 //printf("[OP:xpos=%i,spos=%i,epos=%i>", xpos, startPos, endPos);
929 // This is correct, the OP line buffer is a constant size...
931 int32 lbufWidth = 719;
933 // If the image is completely to the left or right of the line buffer, then bail.
934 //If in REFLECT mode, then these values are swapped! !!! FIX !!! [DONE]
935 //There are four possibilities:
936 // 1. image sits on left edge and no REFLECT; starts out of bounds but ends in bounds.
937 // 2. image sits on left edge and REFLECT; starts in bounds but ends out of bounds.
938 // 3. image sits on right edge and REFLECT; starts out of bounds but ends in bounds.
939 // 4. image sits on right edge and no REFLECT; starts in bounds but ends out of bounds.
940 //Numbers 2 & 4 can be caught by checking the LBUF clip while in the inner loop,
941 // numbers 1 & 3 are of concern.
942 // This *indirectly* handles only cases 2 & 4! And is WRONG is REFLECT is set...!
943 // if (rightMargin < 0 || leftMargin > lbufWidth)
945 // It might be easier to swap these (if REFLECTed) and just use XPOS down below...
946 // That way, you could simply set XPOS to leftMargin if !REFLECT and to rightMargin otherwise.
947 // Still have to be careful with the DATA and IWIDTH values though...
949 // if ((!flagREFLECT && (rightMargin < 0 || leftMargin > lbufWidth))
950 // || (flagREFLECT && (leftMargin < 0 || rightMargin > lbufWidth)))
952 if ((!flagREFLECT && (endPos < 0 || startPos > lbufWidth))
953 || (flagREFLECT && (startPos < 0 || endPos > lbufWidth)))
956 // Otherwise, find the clip limits and clip the phrase as well...
957 // NOTE: I'm fudging here by letting the actual blit overstep the bounds of the
958 // line buffer, but it shouldn't matter since there are two unused line
959 // buffers below and nothing above and I'll at most write 8 bytes outside
960 // the line buffer... I could use a fractional clip begin/end value, but
961 // this makes the blit a *lot* more hairy. I might fix this in the future
962 // if it becomes necessary. (JLH)
963 // Probably wouldn't be *that* hairy. Just use a delta that tells the inner loop
964 // which pixel in the phrase is being written, and quit when either end of phrases
965 // is reached or line buffer extents are surpassed.
967 //This stuff is probably wrong as well... !!! FIX !!!
968 //The strange thing is that it seems to work, but that's no guarantee that it's bulletproof!
969 //Yup. Seems that JagMania doesn't work correctly with this...
970 //Dunno if this is the problem, but Atari Karts is showing *some* of the road now...
975 clippedWidth = 0 - leftMargin,
976 phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth],
977 leftMargin = 0 - (clippedWidth % phraseWidthToPixels[depth]);
980 if (rightMargin > lbufWidth)
981 clippedWidth = rightMargin - lbufWidth,
982 phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth];//,
983 // rightMargin = lbufWidth + (clippedWidth % phraseWidthToPixels[depth]);
984 // rightMargin = lbufWidth;
987 WriteLog("OP: We're about to encounter a divide by zero error!\n");
988 // NOTE: We're just using endPos to figure out how much, if any, to clip by.
989 // ALSO: There may be another case where we start out of bounds and end out of bounds...!
991 if (startPos < 0) // Case #1: Begin out, end in, L to R
992 clippedWidth = 0 - startPos,
993 dataClippedWidth = phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth],
994 startPos = 0 - (clippedWidth % phraseWidthToPixels[depth]);
996 if (endPos < 0) // Case #2: Begin in, end out, R to L
997 clippedWidth = 0 - endPos,
998 phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth];
1000 if (endPos > lbufWidth) // Case #3: Begin in, end out, L to R
1001 clippedWidth = endPos - lbufWidth,
1002 phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth];
1004 if (startPos > lbufWidth) // Case #4: Begin out, end in, R to L
1005 clippedWidth = startPos - lbufWidth,
1006 dataClippedWidth = phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth],
1007 startPos = lbufWidth + (clippedWidth % phraseWidthToPixels[depth]);
1008 //printf("<OP:spos=%i,epos=%i]", startPos, endPos);
1010 // If the image is sitting on the line buffer left or right edge, we need to compensate
1011 // by decreasing the image phrase width accordingly.
1012 iwidth -= phraseClippedWidth;
1014 // Also, if we're clipping the phrase we need to make sure we're in the correct part of
1016 // data += phraseClippedWidth * (pitch << 3);
1017 data += dataClippedWidth * pitch;
1019 // NOTE: When the bitmap is in REFLECT mode, the XPOS marks the *right* side of the
1020 // bitmap! This makes clipping & etc. MUCH, much easier...!
1021 // uint32 lbufAddress = 0x1800 + (!in24BPPMode ? leftMargin * 2 : leftMargin * 4);
1022 //Why does this work right when multiplying startPos by 2 (instead of 4) for 24 BPP mode?
1023 //Is this a bug in the OP?
1024 //It's because in 24bpp mode, each pixel takes *4* bytes, instead of the usual 2.
1025 //Though it looks like we're doing it here no matter what...
1026 // uint32 lbufAddress = 0x1800 + (!in24BPPMode ? startPos * 2 : startPos * 2);
1028 uint32 lbufAddress = 0x1800 + (startPos * 2);
1029 uint8 * currentLineBuffer = &tomRam8[lbufAddress];
1033 // Hmm. We check above for 24 BPP mode, but don't do anything about it below...
1034 // If we *were* in 24 BPP mode, how would you convert CRY to RGB24? Seems to me
1035 // that if you're in CRY mode then you wouldn't be able to use 24 BPP bitmaps
1037 // This seems to be the case (at least according to the Midsummer docs)...!
1039 // This is to test using palette zeroes instead of bit zeroes...
1040 // And it seems that this is wrong, index == 0 is transparent apparently... :-/
1041 //#define OP_USES_PALETTE_ZERO
1043 if (depth == 0) // 1 BPP
1045 // The LSB of flags is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1046 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1048 // Fetch 1st phrase...
1049 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1050 //Note that firstPix should only be honored *if* we start with the 1st phrase of the bitmap
1051 //i.e., we didn't clip on the margin... !!! FIX !!!
1052 pixels <<= firstPix; // Skip first N pixels (N=firstPix)...
1053 int i = firstPix; // Start counter at right spot...
1059 uint8 bit = pixels >> 63;
1060 #ifndef OP_USES_PALETTE_ZERO
1061 if (flagTRANS && bit == 0)
1063 if (flagTRANS && (paletteRAM16[index | bit] == 0))
1069 //Optimize: Set palleteRAM16 to beginning of palette RAM + index*2 and use only [bit] as index...
1070 //Won't optimize RMW case though...
1071 // This is the *only* correct use of endian-dependent code
1072 // (i.e., mem-to-mem direct copying)!
1073 *(uint16 *)currentLineBuffer = paletteRAM16[index | bit];
1075 *currentLineBuffer =
1076 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bit) << 1]),
1077 *(currentLineBuffer + 1) =
1078 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bit) << 1) + 1]);
1081 currentLineBuffer += lbufDelta;
1085 // Fetch next phrase...
1087 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1090 else if (depth == 1) // 2 BPP
1093 WriteLog("OP: Fixed bitmap @ 2 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1094 index &= 0xFC; // Top six bits form CLUT index
1095 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1096 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1101 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1104 for(int i=0; i<32; i++)
1106 uint8 bits = pixels >> 62;
1107 // Seems to me that both of these are in the same endian, so we could cast it as
1108 // uint16 * and do straight across copies (what about 24 bpp? Treat it differently...)
1109 // This only works for the palettized modes (1 - 8 BPP), since we actually have to
1110 // copy data from memory in 16 BPP mode (or does it? Isn't this the same as the CLUT case?)
1111 // No, it isn't because we read the memory in an endian safe way--this *won't* work...
1112 #ifndef OP_USES_PALETTE_ZERO
1113 if (flagTRANS && bits == 0)
1115 if (flagTRANS && (paletteRAM16[index | bits] == 0))
1121 *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1123 *currentLineBuffer =
1124 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1125 *(currentLineBuffer + 1) =
1126 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1129 currentLineBuffer += lbufDelta;
1134 else if (depth == 2) // 4 BPP
1137 WriteLog("OP: Fixed bitmap @ 4 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1138 index &= 0xF0; // Top four bits form CLUT index
1139 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1140 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1145 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1148 for(int i=0; i<16; i++)
1150 uint8 bits = pixels >> 60;
1151 // Seems to me that both of these are in the same endian, so we could cast it as
1152 // uint16 * and do straight across copies (what about 24 bpp? Treat it differently...)
1153 // This only works for the palettized modes (1 - 8 BPP), since we actually have to
1154 // copy data from memory in 16 BPP mode (or does it? Isn't this the same as the CLUT case?)
1155 // No, it isn't because we read the memory in an endian safe way--this *won't* work...
1156 #ifndef OP_USES_PALETTE_ZERO
1157 if (flagTRANS && bits == 0)
1159 if (flagTRANS && (paletteRAM16[index | bits] == 0))
1165 *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1167 *currentLineBuffer =
1168 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1169 *(currentLineBuffer + 1) =
1170 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1173 currentLineBuffer += lbufDelta;
1178 else if (depth == 3) // 8 BPP
1180 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1181 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1183 // Fetch 1st phrase...
1184 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1185 //Note that firstPix should only be honored *if* we start with the 1st phrase of the bitmap
1186 //i.e., we didn't clip on the margin... !!! FIX !!!
1187 firstPix &= 0x30; // Only top two bits are valid for 8 BPP
1188 pixels <<= firstPix; // Skip first N pixels (N=firstPix)...
1189 int i = firstPix >> 3; // Start counter at right spot...
1195 uint8 bits = pixels >> 56;
1196 // Seems to me that both of these are in the same endian, so we could cast it as
1197 // uint16 * and do straight across copies (what about 24 bpp? Treat it differently...)
1198 // This only works for the palettized modes (1 - 8 BPP), since we actually have to
1199 // copy data from memory in 16 BPP mode (or does it? Isn't this the same as the CLUT case?)
1200 // No, it isn't because we read the memory in an endian safe way--this *won't* work...
1201 //This would seem to be problematic...
1202 //Because it's the palette entry being zero that makes the pixel transparent...
1203 //Let's try it and see.
1204 #ifndef OP_USES_PALETTE_ZERO
1205 if (flagTRANS && bits == 0)
1207 if (flagTRANS && (paletteRAM16[bits] == 0))
1213 *(uint16 *)currentLineBuffer = paletteRAM16[bits];
1215 *currentLineBuffer =
1216 BLEND_CR(*currentLineBuffer, paletteRAM[bits << 1]),
1217 *(currentLineBuffer + 1) =
1218 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[(bits << 1) + 1]);
1221 currentLineBuffer += lbufDelta;
1225 // Fetch next phrase...
1227 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1230 else if (depth == 4) // 16 BPP
1233 WriteLog("OP: Fixed bitmap @ 16 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1234 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1235 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1240 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1243 for(int i=0; i<4; i++)
1245 uint8 bitsHi = pixels >> 56, bitsLo = pixels >> 48;
1246 // Seems to me that both of these are in the same endian, so we could cast it as
1247 // uint16 * and do straight across copies (what about 24 bpp? Treat it differently...)
1248 // This only works for the palettized modes (1 - 8 BPP), since we actually have to
1249 // copy data from memory in 16 BPP mode (or does it? Isn't this the same as the CLUT case?)
1250 // No, it isn't because we read the memory in an endian safe way--it *won't* work...
1251 //This doesn't seem right... Let's try the encoded black value ($8800):
1252 //Apparently, CRY 0 maps to $8800...
1253 if (flagTRANS && ((bitsLo | bitsHi) == 0))
1254 // if (flagTRANS && (bitsHi == 0x88) && (bitsLo == 0x00))
1259 *currentLineBuffer = bitsHi,
1260 *(currentLineBuffer + 1) = bitsLo;
1262 *currentLineBuffer =
1263 BLEND_CR(*currentLineBuffer, bitsHi),
1264 *(currentLineBuffer + 1) =
1265 BLEND_Y(*(currentLineBuffer + 1), bitsLo);
1268 currentLineBuffer += lbufDelta;
1273 else if (depth == 5) // 24 BPP
1275 //Looks like Iron Soldier is the only game that uses 24BPP mode...
1276 //There *might* be others...
1277 //WriteLog("OP: Writing 24 BPP bitmap!\n");
1279 WriteLog("OP: Fixed bitmap @ 24 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1280 // Not sure, but I think RMW only works with 16 BPP and below, and only in CRY mode...
1281 // The LSB of flags is OPFLAG_REFLECT, so sign extend it and OR 4 into it.
1282 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 4) | 0x04;
1287 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1290 for(int i=0; i<2; i++)
1292 // We don't use a 32-bit var here because of endian issues...!
1293 uint8 bits3 = pixels >> 56, bits2 = pixels >> 48,
1294 bits1 = pixels >> 40, bits0 = pixels >> 32;
1296 if (flagTRANS && (bits3 | bits2 | bits1 | bits0) == 0)
1299 *currentLineBuffer = bits3,
1300 *(currentLineBuffer + 1) = bits2,
1301 *(currentLineBuffer + 2) = bits1,
1302 *(currentLineBuffer + 3) = bits0;
1304 currentLineBuffer += lbufDelta;
1312 // Store scaled bitmap in line buffer
1314 void OPProcessScaledBitmap(uint64 p0, uint64 p1, uint64 p2, bool render)
1316 // Need to make sure that when writing that it stays within the line buffer...
1317 // LBUF ($F01800 - $F01D9E) 360 x 32-bit RAM
1318 uint8 depth = (p1 >> 12) & 0x07; // Color depth of image
1319 int32 xpos = ((int16)((p1 << 4) & 0xFFFF)) >> 4;// Image xpos in LBUF
1320 uint32 iwidth = (p1 >> 28) & 0x3FF; // Image width in *phrases*
1321 uint32 data = (p0 >> 40) & 0xFFFFF8; // Pixel data address
1322 //#ifdef OP_DEBUG_BMP
1323 // Prolly should use this... Though not sure exactly how.
1324 //Use the upper bits as an offset into the phrase depending on the BPP. That's how!
1325 uint32 firstPix = (p1 >> 49) & 0x3F;
1326 //This is WEIRD! I'm sure I saw Atari Karts request 8 BPP FIRSTPIX! What happened???
1328 WriteLog("OP: FIRSTPIX != 0! (Scaled BM)\n");
1330 // We can ignore the RELEASE (high order) bit for now--probably forever...!
1331 // uint8 flags = (p1 >> 45) & 0x0F; // REFLECT, RMW, TRANS, RELEASE
1332 //Optimize: break these out to their own BOOL values [DONE]
1333 uint8 flags = (p1 >> 45) & 0x07; // REFLECT (0), RMW (1), TRANS (2)
1334 bool flagREFLECT = (flags & OPFLAG_REFLECT ? true : false),
1335 flagRMW = (flags & OPFLAG_RMW ? true : false),
1336 flagTRANS = (flags & OPFLAG_TRANS ? true : false);
1337 uint8 index = (p1 >> 37) & 0xFE; // CLUT index offset (upper pix, 1-4 bpp)
1338 uint32 pitch = (p1 >> 15) & 0x07; // Phrase pitch
1340 uint8 * tomRam8 = TOMGetRamPointer();
1341 uint8 * paletteRAM = &tomRam8[0x400];
1342 // This is OK as long as it's used correctly: For 16-bit RAM to RAM direct copies--NOT
1343 // for use when using endian-corrected data (i.e., any of the *ReadWord functions!)
1344 uint16 * paletteRAM16 = (uint16 *)paletteRAM;
1346 uint16 hscale = p2 & 0xFF;
1347 // Hmm. It seems that fixing the horizontal scale necessitated re-fixing this. Not sure why,
1348 // but seems to be consistent with the vertical scaling now (and it may turn out to be wrong!)...
1349 uint16 horizontalRemainder = hscale; // Not sure if it starts full, but seems reasonable [It's not!]
1350 // uint8 horizontalRemainder = 0; // Let's try zero! Seems to work! Yay! [No, it doesn't!]
1351 int32 scaledWidthInPixels = (iwidth * phraseWidthToPixels[depth] * hscale) >> 5;
1352 uint32 scaledPhrasePixels = (phraseWidthToPixels[depth] * hscale) >> 5;
1354 // WriteLog("bitmap %ix? %ibpp at %i,? firstpix=? data=0x%.8x pitch %i hflipped=%s dwidth=? (linked to ?) RMW=%s Tranparent=%s\n",
1355 // iwidth, op_bitmap_bit_depth[bitdepth], xpos, ptr, pitch, (flags&OPFLAG_REFLECT ? "yes" : "no"), (flags&OPFLAG_RMW ? "yes" : "no"), (flags&OPFLAG_TRANS ? "yes" : "no"));
1357 // Looks like an hscale of zero means don't draw!
1358 if (!render || iwidth == 0 || hscale == 0)
1361 /*extern int start_logging;
1363 WriteLog("OP: Scaled bitmap %ix? %ibpp at %i,? hscale=%02X fpix=%i data=%08X pitch %i hflipped=%s dwidth=? (linked to %08X) Transluency=%s\n",
1364 iwidth, op_bitmap_bit_depth[depth], xpos, hscale, firstPix, data, pitch, (flagREFLECT ? "yes" : "no"), op_pointer, (flagRMW ? "yes" : "no"));*/
1365 //#define OP_DEBUG_BMP
1366 //#ifdef OP_DEBUG_BMP
1367 // WriteLog("OP: Scaled bitmap %ix%i %ibpp at %i,%i firstpix=%i data=0x%.8x pitch %i hflipped=%s dwidth=%i (linked to 0x%.8x) Transluency=%s\n",
1368 // iwidth, height, op_bitmap_bit_depth[bitdepth], xpos, ypos, firstPix, ptr, pitch, (flags&OPFLAG_REFLECT ? "yes" : "no"), dwidth, op_pointer, (flags&OPFLAG_RMW ? "yes" : "no"));
1371 int32 startPos = xpos, endPos = xpos +
1372 (!flagREFLECT ? scaledWidthInPixels - 1 : -(scaledWidthInPixels + 1));
1373 uint32 clippedWidth = 0, phraseClippedWidth = 0, dataClippedWidth = 0;
1374 bool in24BPPMode = (((GET16(tomRam8, 0x0028) >> 1) & 0x03) == 1 ? true : false); // VMODE
1375 // Not sure if this is Jaguar Two only location or what...
1376 // From the docs, it is... If we want to limit here we should think of something else.
1377 // int32 limit = GET16(tom_ram_8, 0x0008); // LIMIT
1379 // int32 lbufWidth = (!in24BPPMode ? limit - 1 : (limit / 2) - 1); // Zero based limit...
1380 int32 lbufWidth = 719; // Zero based limit...
1382 // If the image is completely to the left or right of the line buffer, then bail.
1383 //If in REFLECT mode, then these values are swapped! !!! FIX !!! [DONE]
1384 //There are four possibilities:
1385 // 1. image sits on left edge and no REFLECT; starts out of bounds but ends in bounds.
1386 // 2. image sits on left edge and REFLECT; starts in bounds but ends out of bounds.
1387 // 3. image sits on right edge and REFLECT; starts out of bounds but ends in bounds.
1388 // 4. image sits on right edge and no REFLECT; starts in bounds but ends out of bounds.
1389 //Numbers 2 & 4 can be caught by checking the LBUF clip while in the inner loop,
1390 // numbers 1 & 3 are of concern.
1391 // This *indirectly* handles only cases 2 & 4! And is WRONG if REFLECT is set...!
1392 // if (rightMargin < 0 || leftMargin > lbufWidth)
1394 // It might be easier to swap these (if REFLECTed) and just use XPOS down below...
1395 // That way, you could simply set XPOS to leftMargin if !REFLECT and to rightMargin otherwise.
1396 // Still have to be careful with the DATA and IWIDTH values though...
1398 if ((!flagREFLECT && (endPos < 0 || startPos > lbufWidth))
1399 || (flagREFLECT && (startPos < 0 || endPos > lbufWidth)))
1402 // Otherwise, find the clip limits and clip the phrase as well...
1403 // NOTE: I'm fudging here by letting the actual blit overstep the bounds of the
1404 // line buffer, but it shouldn't matter since there are two unused line
1405 // buffers below and nothing above and I'll at most write 40 bytes outside
1406 // the line buffer... I could use a fractional clip begin/end value, but
1407 // this makes the blit a *lot* more hairy. I might fix this in the future
1408 // if it becomes necessary. (JLH)
1409 // Probably wouldn't be *that* hairy. Just use a delta that tells the inner loop
1410 // which pixel in the phrase is being written, and quit when either end of phrases
1411 // is reached or line buffer extents are surpassed.
1413 //This stuff is probably wrong as well... !!! FIX !!!
1414 //The strange thing is that it seems to work, but that's no guarantee that it's bulletproof!
1415 //Yup. Seems that JagMania doesn't work correctly with this...
1416 //Dunno if this is the problem, but Atari Karts is showing *some* of the road now...
1417 //Actually, it is! Or, it was. It doesn't seem to be clipping here, so the problem lies
1418 //elsewhere! Hmm. Putting the scaling code into the 1/2/8 BPP cases seems to draw the ground
1419 // a bit more accurately... Strange!
1420 //It's probably a case of the REFLECT flag being set and the background being written
1421 //from the right side of the screen...
1422 //But no, it isn't... At least if the diagnostics are telling the truth!
1424 // NOTE: We're just using endPos to figure out how much, if any, to clip by.
1425 // ALSO: There may be another case where we start out of bounds and end out of bounds...!
1428 //There's a problem here with scaledPhrasePixels in that it can be forced to zero when
1429 //the scaling factor is small. So fix it already! !!! FIX !!!
1430 /*if (scaledPhrasePixels == 0)
1432 WriteLog("OP: [Scaled] We're about to encounter a divide by zero error!\n");
1433 DumpScaledObject(p0, p1, p2);
1435 //NOTE: I'm almost 100% sure that this is wrong... And it is! :-p
1437 //Try a simple example...
1438 // Let's say we have a 8 BPP scanline with an hscale of $80 (4). Our xpos is -10,
1439 // non-flipped. Pixels in the bitmap are XYZXYZXYZXYZXYZ.
1440 // Scaled up, they would be XXXXYYYYZZZZXXXXYYYYZZZZXXXXYYYYZZZZ...
1442 // Normally, we would expect this in the line buffer:
1443 // ZZXXXXYYYYZZZZXXXXYYYYZZZZ...
1445 // But instead we're getting:
1446 // XXXXYYYYZZZZXXXXYYYYZZZZ...
1448 // or are we??? It would seem so, simply by virtue of the fact that we're NOT starting
1449 // on negative boundary--or are we? Hmm...
1450 // cw = 10, dcw = pcw = 10 / ([8 * 4 = 32] 32) = 0, sp = -10
1452 // Let's try a real world example:
1454 //OP: Scaled bitmap (70, 8 BPP, spp=28) sp (-400) < 0... [new sp=-8, cw=400, dcw=pcw=14]
1455 //OP: Scaled bitmap (6F, 8 BPP, spp=27) sp (-395) < 0... [new sp=-17, cw=395, dcw=pcw=14]
1457 // Really, spp is 27.75 in the second case...
1458 // So... If we do 395 / 27.75, we get 14. Ok so far... If we scale that against the
1459 // start position (14 * 27.75), we get -6.5... NOT -17!
1461 //Now it seems we're working OK, at least for the first case...
1462 uint32 scaledPhrasePixelsUS = phraseWidthToPixels[depth] * hscale;
1464 if (startPos < 0) // Case #1: Begin out, end in, L to R
1466 extern int start_logging;
1468 WriteLog("OP: Scaled bitmap (%02X, %u BPP, spp=%u) start pos (%i) < 0...", hscale, op_bitmap_bit_depth[depth], scaledPhrasePixels, startPos);
1469 // clippedWidth = 0 - startPos,
1470 clippedWidth = (0 - startPos) << 5,
1471 // dataClippedWidth = phraseClippedWidth = clippedWidth / scaledPhrasePixels,
1472 dataClippedWidth = phraseClippedWidth = (clippedWidth / scaledPhrasePixelsUS) >> 5,
1473 // startPos = 0 - (clippedWidth % scaledPhrasePixels);
1474 startPos += (dataClippedWidth * scaledPhrasePixelsUS) >> 5;
1476 WriteLog(" [new sp=%i, cw=%i, dcw=pcw=%i]\n", startPos, clippedWidth, dataClippedWidth);
1479 if (endPos < 0) // Case #2: Begin in, end out, R to L
1480 clippedWidth = 0 - endPos,
1481 phraseClippedWidth = clippedWidth / scaledPhrasePixels;
1483 if (endPos > lbufWidth) // Case #3: Begin in, end out, L to R
1484 clippedWidth = endPos - lbufWidth,
1485 phraseClippedWidth = clippedWidth / scaledPhrasePixels;
1487 if (startPos > lbufWidth) // Case #4: Begin out, end in, R to L
1488 clippedWidth = startPos - lbufWidth,
1489 dataClippedWidth = phraseClippedWidth = clippedWidth / scaledPhrasePixels,
1490 startPos = lbufWidth + (clippedWidth % scaledPhrasePixels);
1492 extern int op_start_log;
1493 if (op_start_log && clippedWidth != 0)
1494 WriteLog("OP: Clipped line. SP=%i, EP=%i, clip=%u, iwidth=%u, hscale=%02X\n", startPos, endPos, clippedWidth, iwidth, hscale);
1495 if (op_start_log && startPos == 13)
1497 WriteLog("OP: Scaled line. SP=%i, EP=%i, clip=%u, iwidth=%u, hscale=%02X, depth=%u, firstPix=%u\n", startPos, endPos, clippedWidth, iwidth, hscale, depth, firstPix);
1498 DumpScaledObject(p0, p1, p2);
1501 WriteLog(" %08X: ", data);
1502 for(int i=0; i<7*8; i++)
1503 WriteLog("%02X ", JaguarReadByte(data+i));
1507 // If the image is sitting on the line buffer left or right edge, we need to compensate
1508 // by decreasing the image phrase width accordingly.
1509 iwidth -= phraseClippedWidth;
1511 // Also, if we're clipping the phrase we need to make sure we're in the correct part of
1513 // data += phraseClippedWidth * (pitch << 3);
1514 data += dataClippedWidth * (pitch << 3);
1516 // NOTE: When the bitmap is in REFLECT mode, the XPOS marks the *right* side of the
1517 // bitmap! This makes clipping & etc. MUCH, much easier...!
1518 // uint32 lbufAddress = 0x1800 + (!in24BPPMode ? leftMargin * 2 : leftMargin * 4);
1519 // uint32 lbufAddress = 0x1800 + (!in24BPPMode ? startPos * 2 : startPos * 4);
1520 uint32 lbufAddress = 0x1800 + startPos * 2;
1521 uint8 * currentLineBuffer = &tomRam8[lbufAddress];
1522 //uint8 * lineBufferLowerLimit = &tom_ram_8[0x1800],
1523 // * lineBufferUpperLimit = &tom_ram_8[0x1800 + 719];
1527 // Hmm. We check above for 24 BPP mode, but don't do anything about it below...
1528 // If we *were* in 24 BPP mode, how would you convert CRY to RGB24? Seems to me
1529 // that if you're in CRY mode then you wouldn't be able to use 24 BPP bitmaps
1531 // This seems to be the case (at least according to the Midsummer docs)...!
1533 if (depth == 0) // 1 BPP
1536 WriteLog("OP: Scaled bitmap @ 1 BPP requesting FIRSTPIX!\n");
1537 // The LSB of flags is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1538 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1541 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1543 while ((int32)iwidth > 0)
1545 uint8 bits = pixels >> 63;
1547 #ifndef OP_USES_PALETTE_ZERO
1548 if (flagTRANS && bits == 0)
1550 if (flagTRANS && (paletteRAM16[index | bits] == 0))
1556 // This is the *only* correct use of endian-dependent code
1557 // (i.e., mem-to-mem direct copying)!
1558 *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1560 *currentLineBuffer =
1561 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1562 *(currentLineBuffer + 1) =
1563 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1566 currentLineBuffer += lbufDelta;
1569 The reason we subtract the horizontalRemainder *after* the test is because we had too few
1570 bytes for horizontalRemainder to properly recognize a negative number. But now it's 16 bits
1571 wide, so we could probably go back to that (as long as we make it an int16 and not a uint16!)
1573 /* horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1574 while (horizontalRemainder & 0x80)
1576 horizontalRemainder += hscale;
1580 // while (horizontalRemainder <= 0x20) // I.e., it's <= 1.0 (*before* subtraction)
1581 while (horizontalRemainder < 0x20) // I.e., it's <= 1.0 (*before* subtraction)
1583 horizontalRemainder += hscale;
1587 horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1591 int phrasesToSkip = pixCount / 64, pixelShift = pixCount % 64;
1593 data += (pitch << 3) * phrasesToSkip;
1594 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1595 pixels <<= 1 * pixelShift;
1596 iwidth -= phrasesToSkip;
1597 pixCount = pixelShift;
1601 else if (depth == 1) // 2 BPP
1604 WriteLog("OP: Scaled bitmap @ 2 BPP requesting FIRSTPIX!\n");
1605 index &= 0xFC; // Top six bits form CLUT index
1606 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1607 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1610 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1612 while ((int32)iwidth > 0)
1614 uint8 bits = pixels >> 62;
1616 #ifndef OP_USES_PALETTE_ZERO
1617 if (flagTRANS && bits == 0)
1619 if (flagTRANS && (paletteRAM16[index | bits] == 0))
1625 // This is the *only* correct use of endian-dependent code
1626 // (i.e., mem-to-mem direct copying)!
1627 *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1629 *currentLineBuffer =
1630 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1631 *(currentLineBuffer + 1) =
1632 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1635 currentLineBuffer += lbufDelta;
1637 /* horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1638 while (horizontalRemainder & 0x80)
1640 horizontalRemainder += hscale;
1644 // while (horizontalRemainder <= 0x20) // I.e., it's <= 0 (*before* subtraction)
1645 while (horizontalRemainder < 0x20) // I.e., it's <= 1.0 (*before* subtraction)
1647 horizontalRemainder += hscale;
1651 horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1655 int phrasesToSkip = pixCount / 32, pixelShift = pixCount % 32;
1657 data += (pitch << 3) * phrasesToSkip;
1658 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1659 pixels <<= 2 * pixelShift;
1660 iwidth -= phrasesToSkip;
1661 pixCount = pixelShift;
1665 else if (depth == 2) // 4 BPP
1668 WriteLog("OP: Scaled bitmap @ 4 BPP requesting FIRSTPIX!\n");
1669 index &= 0xF0; // Top four bits form CLUT index
1670 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1671 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1674 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1676 while ((int32)iwidth > 0)
1678 uint8 bits = pixels >> 60;
1680 #ifndef OP_USES_PALETTE_ZERO
1681 if (flagTRANS && bits == 0)
1683 if (flagTRANS && (paletteRAM16[index | bits] == 0))
1689 // This is the *only* correct use of endian-dependent code
1690 // (i.e., mem-to-mem direct copying)!
1691 *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1693 *currentLineBuffer =
1694 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1695 *(currentLineBuffer + 1) =
1696 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1699 currentLineBuffer += lbufDelta;
1701 /* horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1702 while (horizontalRemainder & 0x80)
1704 horizontalRemainder += hscale;
1708 // while (horizontalRemainder <= 0x20) // I.e., it's <= 0 (*before* subtraction)
1709 while (horizontalRemainder < 0x20) // I.e., it's <= 0 (*before* subtraction)
1711 horizontalRemainder += hscale;
1715 horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1719 int phrasesToSkip = pixCount / 16, pixelShift = pixCount % 16;
1721 data += (pitch << 3) * phrasesToSkip;
1722 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1723 pixels <<= 4 * pixelShift;
1724 iwidth -= phrasesToSkip;
1725 pixCount = pixelShift;
1729 else if (depth == 3) // 8 BPP
1732 WriteLog("OP: Scaled bitmap @ 8 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1733 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1734 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1737 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1739 while ((int32)iwidth > 0)
1741 uint8 bits = pixels >> 56;
1743 #ifndef OP_USES_PALETTE_ZERO
1744 if (flagTRANS && bits == 0)
1746 if (flagTRANS && (paletteRAM16[bits] == 0))
1752 // This is the *only* correct use of endian-dependent code
1753 // (i.e., mem-to-mem direct copying)!
1754 *(uint16 *)currentLineBuffer = paletteRAM16[bits];
1756 if (currentLineBuffer >= lineBufferLowerLimit && currentLineBuffer <= lineBufferUpperLimit)
1757 *(uint16 *)currentLineBuffer = paletteRAM16[bits];
1760 *currentLineBuffer =
1761 BLEND_CR(*currentLineBuffer, paletteRAM[bits << 1]),
1762 *(currentLineBuffer + 1) =
1763 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[(bits << 1) + 1]);
1766 currentLineBuffer += lbufDelta;
1768 // while (horizontalRemainder <= 0x20) // I.e., it's <= 0 (*before* subtraction)
1769 while (horizontalRemainder < 0x20) // I.e., it's <= 1.0 (*before* subtraction)
1771 horizontalRemainder += hscale;
1775 horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1779 int phrasesToSkip = pixCount / 8, pixelShift = pixCount % 8;
1781 data += (pitch << 3) * phrasesToSkip;
1782 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1783 pixels <<= 8 * pixelShift;
1784 iwidth -= phrasesToSkip;
1785 pixCount = pixelShift;
1789 else if (depth == 4) // 16 BPP
1792 WriteLog("OP: Scaled bitmap @ 16 BPP requesting FIRSTPIX!\n");
1793 // The LSB is OPFLAG_REFLECT, so sign extend it and OR 2 into it.
1794 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1797 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1799 while ((int32)iwidth > 0)
1801 uint8 bitsHi = pixels >> 56, bitsLo = pixels >> 48;
1803 //This doesn't seem right... Let's try the encoded black value ($8800):
1804 //Apparently, CRY 0 maps to $8800...
1805 if (flagTRANS && ((bitsLo | bitsHi) == 0))
1806 // if (flagTRANS && (bitsHi == 0x88) && (bitsLo == 0x00))
1811 *currentLineBuffer = bitsHi,
1812 *(currentLineBuffer + 1) = bitsLo;
1814 *currentLineBuffer =
1815 BLEND_CR(*currentLineBuffer, bitsHi),
1816 *(currentLineBuffer + 1) =
1817 BLEND_Y(*(currentLineBuffer + 1), bitsLo);
1820 currentLineBuffer += lbufDelta;
1822 /* horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1823 while (horizontalRemainder & 0x80)
1825 horizontalRemainder += hscale;
1829 // while (horizontalRemainder <= 0x20) // I.e., it's <= 0 (*before* subtraction)
1830 while (horizontalRemainder < 0x20) // I.e., it's <= 1.0 (*before* subtraction)
1832 horizontalRemainder += hscale;
1836 horizontalRemainder -= 0x20; // Subtract 1.0f in [3.5] fixed point format
1840 int phrasesToSkip = pixCount / 4, pixelShift = pixCount % 4;
1842 data += (pitch << 3) * phrasesToSkip;
1843 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1844 pixels <<= 16 * pixelShift;
1846 iwidth -= phrasesToSkip;
1848 pixCount = pixelShift;
1852 else if (depth == 5) // 24 BPP
1854 //I'm not sure that you can scale a 24 BPP bitmap properly--the JTRM seem to indicate as much.
1855 WriteLog("OP: Writing 24 BPP scaled bitmap!\n");
1857 WriteLog("OP: Scaled bitmap @ 24 BPP requesting FIRSTPIX!\n");
1858 // Not sure, but I think RMW only works with 16 BPP and below, and only in CRY mode...
1859 // The LSB is OPFLAG_REFLECT, so sign extend it and or 4 into it.
1860 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 4) | 0x04;
1865 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1866 data += pitch << 3; // Multiply pitch * 8 (optimize: precompute this value)
1868 for(int i=0; i<2; i++)
1870 uint8 bits3 = pixels >> 56, bits2 = pixels >> 48,
1871 bits1 = pixels >> 40, bits0 = pixels >> 32;
1873 if (flagTRANS && (bits3 | bits2 | bits1 | bits0) == 0)
1876 *currentLineBuffer = bits3,
1877 *(currentLineBuffer + 1) = bits2,
1878 *(currentLineBuffer + 2) = bits1,
1879 *(currentLineBuffer + 3) = bits0;
1881 currentLineBuffer += lbufDelta;