Shamusworld >> Repos - virtualjaguar/blob - src/op.cpp

   1 //
   2 // Object Processor
   3 //
   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 L. Hammons
   7 // (C) 2010 Underground Software
   8 //
   9 // JLH = James L. Hammons <jlhamm@acm.org>
  10 //
  11 // Who  When        What
  12 // ---  ----------  -------------------------------------------------------------
  13 // JLH  01/16/2010  Created this log ;-)
  14 //
  15
  16 #include "op.h"
  17
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include "gpu.h"
  21 #include "jaguar.h"
  22 #include "log.h"
  23 #include "m68k.h"
  24 #include "memory.h"
  25 #include "tom.h"
  26
  27 //#define OP_DEBUG
  28 //#define OP_DEBUG_BMP
  29
  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))]
  32
  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
  38
  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
  44
  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
  49
  50 // Private function prototypes
  51
  52 void OPProcessFixedBitmap(uint64 p0, uint64 p1, bool render);
  53 void OPProcessScaledBitmap(uint64 p0, uint64 p1, uint64 p2, bool render);
  54 void DumpScaledObject(uint64 p0, uint64 p1, uint64 p2);
  55 void DumpFixedObject(uint64 p0, uint64 p1);
  56 uint64 OPLoadPhrase(uint32 offset);
  57
  58 // Local global variables
  59
  60 // Blend tables (64K each)
  61 static uint8 op_blend_y[0x10000];
  62 static uint8 op_blend_cr[0x10000];
  63 // There may be a problem with this "RAM" overlapping (and thus being independent of)
  64 // some of the regular TOM RAM...
  65 //#warning objectp_ram is separated from TOM RAM--need to fix that!
  66 //static uint8 objectp_ram[0x40];                       // This is based at $F00000
  67 uint8 objectp_running = 0;
  68 //bool objectp_stop_reading_list;
  69
  70 static uint8 op_bitmap_bit_depth[8] = { 1, 2, 4, 8, 16, 24, 32, 0 };
  71 //static uint32 op_bitmap_bit_size[8] =
  72 //      { (uint32)(0.125*65536), (uint32)(0.25*65536), (uint32)(0.5*65536), (uint32)(1*65536),
  73 //        (uint32)(2*65536),     (uint32)(1*65536),    (uint32)(1*65536),   (uint32)(1*65536) };
  74 static uint32 op_pointer;
  75
  76 int32 phraseWidthToPixels[8] = { 64, 32, 16, 8, 4, 2, 0, 0 };
  77
  78
  79 //
  80 // Object Processor initialization
  81 //
  82 void OPInit(void)
  83 {
  84         // Here we calculate the saturating blend of a signed 4-bit value and an
  85         // existing Cyan/Red value as well as a signed 8-bit value and an existing intensity...
  86         // Note: CRY is 4 bits Cyan, 4 bits Red, 16 bits intensitY
  87         for(int i=0; i<256*256; i++)
  88         {
  89                 int y = (i >> 8) & 0xFF;
  90                 int dy = (int8)i;                                       // Sign extend the Y index
  91                 int c1 = (i >> 8) & 0x0F;
  92                 int dc1 = (int8)(i << 4) >> 4;          // Sign extend the R index
  93                 int c2 = (i >> 12) & 0x0F;
  94                 int dc2 = (int8)(i & 0xF0) >> 4;        // Sign extend the C index
  95
  96                 y += dy;
  97
  98                 if (y < 0)
  99                         y = 0;
 100                 else if (y > 0xFF)
 101                         y = 0xFF;
 102
 103                 op_blend_y[i] = y;
 104
 105                 c1 += dc1;
 106
 107                 if (c1 < 0)
 108                         c1 = 0;
 109                 else if (c1 > 0x0F)
 110                         c1 = 0x0F;
 111
 112                 c2 += dc2;
 113
 114                 if (c2 < 0)
 115                         c2 = 0;
 116                 else if (c2 > 0x0F)
 117                         c2 = 0x0F;
 118
 119                 op_blend_cr[i] = (c2 << 4) | c1;
 120         }
 121
 122         OPReset();
 123 }
 124
 125 //
 126 // Object Processor reset
 127 //
 128 void OPReset(void)
 129 {
 130 //      memset(objectp_ram, 0x00, 0x40);
 131         objectp_running = 0;
 132 }
 133
 134 void OPDone(void)
 135 {
 136         const char * opType[8] =
 137         { "(BITMAP)", "(SCALED BITMAP)", "(GPU INT)", "(BRANCH)", "(STOP)", "???", "???", "???" };
 138         const char * ccType[8] =
 139                 { "\"==\"", "\"<\"", "\">\"", "(opflag set)", "(second half line)", "?", "?", "?" };
 140
 141         uint32 olp = OPGetListPointer();
 142         WriteLog("OP: OLP = %08X\n", olp);
 143         WriteLog("OP: Phrase dump\n    ----------\n");
 144         for(uint32 i=0; i<0x100; i+=8)
 145         {
 146                 uint32 hi = JaguarReadLong(olp + i, OP), lo = JaguarReadLong(olp + i + 4, OP);
 147                 WriteLog("\t%08X: %08X %08X %s", olp + i, hi, lo, opType[lo & 0x07]);
 148                 if ((lo & 0x07) == 3)
 149                 {
 150                         uint16 ypos = (lo >> 3) & 0x7FF;
 151                         uint8  cc   = (lo >> 14) & 0x03;
 152                         uint32 link = ((hi << 11) | (lo >> 21)) & 0x3FFFF8;
 153                         WriteLog(" YPOS=%u, CC=%s, link=%08X", ypos, ccType[cc], link);
 154                 }
 155                 WriteLog("\n");
 156                 if ((lo & 0x07) == 0)
 157                         DumpFixedObject(OPLoadPhrase(olp+i), OPLoadPhrase(olp+i+8));
 158                 if ((lo & 0x07) == 1)
 159                         DumpScaledObject(OPLoadPhrase(olp+i), OPLoadPhrase(olp+i+8), OPLoadPhrase(olp+i+16));
 160         }
 161         WriteLog("\n");
 162
 163 //      memory_free(op_blend_y);
 164 //      memory_free(op_blend_cr);
 165 }
 166
 167 //
 168 // Object Processor memory access
 169 // Memory range: F00010 - F00027
 170 //
 171 //      F00010-F00017   R     xxxxxxxx xxxxxxxx   OB - current object code from the graphics processor
 172 //      F00020-F00023     W   xxxxxxxx xxxxxxxx   OLP - start of the object list
 173 //      F00026            W   -------- -------x   OBF - object processor flag
 174 //
 175
 176 #if 0
 177 uint8 OPReadByte(uint32 offset, uint32 who/*=UNKNOWN*/)
 178 {
 179         offset &= 0x3F;
 180         return objectp_ram[offset];
 181 }
 182
 183 uint16 OPReadWord(uint32 offset, uint32 who/*=UNKNOWN*/)
 184 {
 185         offset &= 0x3F;
 186         return GET16(objectp_ram, offset);
 187 }
 188
 189 void OPWriteByte(uint32 offset, uint8 data, uint32 who/*=UNKNOWN*/)
 190 {
 191         offset &= 0x3F;
 192         objectp_ram[offset] = data;
 193 }
 194
 195 void OPWriteWord(uint32 offset, uint16 data, uint32 who/*=UNKNOWN*/)
 196 {
 197         offset &= 0x3F;
 198         SET16(objectp_ram, offset, data);
 199
 200 /*if (offset == 0x20)
 201 WriteLog("OP: Setting lo list pointer: %04X\n", data);
 202 if (offset == 0x22)
 203 WriteLog("OP: Setting hi list pointer: %04X\n", data);//*/
 204 }
 205 #endif
 206
 207 uint32 OPGetListPointer(void)
 208 {
 209         // Note: This register is LO / HI WORD, hence the funky look of this...
 210         return GET16(tomRam8, 0x20) | (GET16(tomRam8, 0x22) << 16);
 211 }
 212
 213 // This is WRONG, since the OBF is only 16 bits wide!!! [FIXED]
 214
 215 uint32 OPGetStatusRegister(void)
 216 {
 217         return GET16(tomRam8, 0x26);
 218 }
 219
 220 // This is WRONG, since the OBF is only 16 bits wide!!! [FIXED]
 221
 222 void OPSetStatusRegister(uint32 data)
 223 {
 224         tomRam8[0x26] = (data & 0x0000FF00) >> 8;
 225         tomRam8[0x27] |= (data & 0xFE);
 226 }
 227
 228 void OPSetCurrentObject(uint64 object)
 229 {
 230 //Not sure this is right... Wouldn't it just be stored 64 bit BE?
 231         // Stored as least significant 32 bits first, ms32 last in big endian
 232 /*      objectp_ram[0x13] = object & 0xFF; object >>= 8;
 233         objectp_ram[0x12] = object & 0xFF; object >>= 8;
 234         objectp_ram[0x11] = object & 0xFF; object >>= 8;
 235         objectp_ram[0x10] = object & 0xFF; object >>= 8;
 236
 237         objectp_ram[0x17] = object & 0xFF; object >>= 8;
 238         objectp_ram[0x16] = object & 0xFF; object >>= 8;
 239         objectp_ram[0x15] = object & 0xFF; object >>= 8;
 240         objectp_ram[0x14] = object & 0xFF;*/
 241 // Let's try regular good old big endian...
 242         tomRam8[0x17] = object & 0xFF; object >>= 8;
 243         tomRam8[0x16] = object & 0xFF; object >>= 8;
 244         tomRam8[0x15] = object & 0xFF; object >>= 8;
 245         tomRam8[0x14] = object & 0xFF; object >>= 8;
 246
 247         tomRam8[0x13] = object & 0xFF; object >>= 8;
 248         tomRam8[0x12] = object & 0xFF; object >>= 8;
 249         tomRam8[0x11] = object & 0xFF; object >>= 8;
 250         tomRam8[0x10] = object & 0xFF;
 251 }
 252
 253 uint64 OPLoadPhrase(uint32 offset)
 254 {
 255         offset &= ~0x07;                                                // 8 byte alignment
 256         return ((uint64)JaguarReadLong(offset, OP) << 32) | (uint64)JaguarReadLong(offset+4, OP);
 257 }
 258
 259 void OPStorePhrase(uint32 offset, uint64 p)
 260 {
 261         offset &= ~0x07;                                                // 8 byte alignment
 262         JaguarWriteLong(offset, p >> 32, OP);
 263         JaguarWriteLong(offset + 4, p & 0xFFFFFFFF, OP);
 264 }
 265
 266 //
 267 // Debugging routines
 268 //
 269 void DumpScaledObject(uint64 p0, uint64 p1, uint64 p2)
 270 {
 271         WriteLog(" (SCALED BITMAP)");
 272         WriteLog(" %08X --> phrase %08X %08X\n", op_pointer, (uint32)(p1>>32), (uint32)(p1&0xFFFFFFFF));
 273         WriteLog("                 %08X --> phrase %08X %08X ", op_pointer+8, (uint32)(p2>>32), (uint32)(p2&0xFFFFFFFF));
 274         uint8 bitdepth = (p1 >> 12) & 0x07;
 275 //WAS:  int16 ypos = ((p0 >> 3) & 0x3FF);                       // ??? What if not interlaced (/2)?
 276         int16 ypos = ((p0 >> 3) & 0x7FF);                       // ??? What if not interlaced (/2)?
 277         int32 xpos = p1 & 0xFFF;
 278         xpos = (xpos & 0x800 ? xpos | 0xFFFFF000 : xpos);
 279         uint32 iwidth = ((p1 >> 28) & 0x3FF);
 280         uint32 dwidth = ((p1 >> 18) & 0x3FF);           // Unsigned!
 281         uint16 height = ((p0 >> 14) & 0x3FF);
 282         uint32 link = ((p0 >> 24) & 0x7FFFF) << 3;
 283         uint32 ptr = ((p0 >> 43) & 0x1FFFFF) << 3;
 284         uint32 firstPix = (p1 >> 49) & 0x3F;
 285         uint8 flags = (p1 >> 45) & 0x0F;
 286         uint8 idx = (p1 >> 38) & 0x7F;
 287         uint32 pitch = (p1 >> 15) & 0x07;
 288         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",
 289                 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);
 290         uint32 hscale = p2 & 0xFF;
 291         uint32 vscale = (p2 >> 8) & 0xFF;
 292         uint32 remainder = (p2 >> 16) & 0xFF;
 293         WriteLog("    [hsc: %02X, vsc: %02X, rem: %02X]\n", hscale, vscale, remainder);
 294 }
 295
 296 void DumpFixedObject(uint64 p0, uint64 p1)
 297 {
 298         WriteLog(" (BITMAP)");
 299         WriteLog(" %08X --> phrase %08X %08X\n", op_pointer, (uint32)(p1>>32), (uint32)(p1&0xFFFFFFFF));
 300         uint8 bitdepth = (p1 >> 12) & 0x07;
 301 //WAS:  int16 ypos = ((p0 >> 3) & 0x3FF);                       // ??? What if not interlaced (/2)?
 302         int16 ypos = ((p0 >> 3) & 0x7FF);                       // ??? What if not interlaced (/2)?
 303         int32 xpos = p1 & 0xFFF;
 304         xpos = (xpos & 0x800 ? xpos | 0xFFFFF000 : xpos);
 305         uint32 iwidth = ((p1 >> 28) & 0x3FF);
 306         uint32 dwidth = ((p1 >> 18) & 0x3FF);           // Unsigned!
 307         uint16 height = ((p0 >> 14) & 0x3FF);
 308         uint32 link = ((p0 >> 24) & 0x7FFFF) << 3;
 309         uint32 ptr = ((p0 >> 43) & 0x1FFFFF) << 3;
 310         uint32 firstPix = (p1 >> 49) & 0x3F;
 311         uint8 flags = (p1 >> 45) & 0x0F;
 312         uint8 idx = (p1 >> 38) & 0x7F;
 313         uint32 pitch = (p1 >> 15) & 0x07;
 314         WriteLog("    [%u (%u) x %u @ (%i, %u) (%u bpp), l: %08X, p: %08X fp: %02X, fl:%s%s%s%s, idx:%02X, pt:%02X]\n",
 315                 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);
 316 }
 317
 318 //
 319 // Object Processor main routine
 320 //
 321 #warning "Need to fix this so that when an GPU object IRQ happens, we can pick up OP processing where we left off. !!! FIX !!!"
 322 void OPProcessList(int scanline, bool render)
 323 {
 324 extern int op_start_log;
 325 //      char * condition_to_str[8] =
 326 //              { "==", "<", ">", "(opflag set)", "(second half line)", "?", "?", "?" };
 327
 328         op_pointer = OPGetListPointer();
 329
 330 //      objectp_stop_reading_list = false;
 331
 332 //WriteLog("OP: Processing line #%u (OLP=%08X)...\n", scanline, op_pointer);
 333 //op_done();
 334
 335 // *** BEGIN OP PROCESSOR TESTING ONLY ***
 336 extern bool interactiveMode;
 337 extern bool iToggle;
 338 extern int objectPtr;
 339 bool inhibit;
 340 int bitmapCounter = 0;
 341 // *** END OP PROCESSOR TESTING ONLY ***
 342
 343         uint32 opCyclesToRun = 30000;                                   // This is a pulled-out-of-the-air value (will need to be fixed, obviously!)
 344
 345 //      if (op_pointer) WriteLog(" new op list at 0x%.8x scanline %i\n",op_pointer,scanline);
 346         while (op_pointer)
 347         {
 348 // *** BEGIN OP PROCESSOR TESTING ONLY ***
 349 if (interactiveMode && bitmapCounter == objectPtr)
 350         inhibit = iToggle;
 351 else
 352         inhibit = false;
 353 // *** END OP PROCESSOR TESTING ONLY ***
 354 //              if (objectp_stop_reading_list)
 355 //                      return;
 356
 357                 uint64 p0 = OPLoadPhrase(op_pointer);
 358 //WriteLog("\t%08X type %i\n", op_pointer, (uint8)p0 & 0x07);
 359                 op_pointer += 8;
 360
 361 #if 1
 362 if (scanline == TOMGetVDB() && op_start_log)
 363 //if (scanline == 215 && op_start_log)
 364 //if (scanline == 28 && op_start_log)
 365 //if (scanline == 0)
 366 {
 367 WriteLog("%08X --> phrase %08X %08X", op_pointer - 8, (int)(p0>>32), (int)(p0&0xFFFFFFFF));
 368 if ((p0 & 0x07) == OBJECT_TYPE_BITMAP)
 369 {
 370 WriteLog(" (BITMAP) ");
 371 uint64 p1 = OPLoadPhrase(op_pointer);
 372 WriteLog("\n%08X --> phrase %08X %08X ", op_pointer, (int)(p1>>32), (int)(p1&0xFFFFFFFF));
 373         uint8 bitdepth = (p1 >> 12) & 0x07;
 374 //WAS:  int16 ypos = ((p0 >> 3) & 0x3FF);                       // ??? What if not interlaced (/2)?
 375         int16 ypos = ((p0 >> 3) & 0x7FF);                       // ??? What if not interlaced (/2)?
 376 int32 xpos = p1 & 0xFFF;
 377 xpos = (xpos & 0x800 ? xpos | 0xFFFFF000 : xpos);
 378         uint32 iwidth = ((p1 >> 28) & 0x3FF);
 379         uint32 dwidth = ((p1 >> 18) & 0x3FF);           // Unsigned!
 380         uint16 height = ((p0 >> 14) & 0x3FF);
 381         uint32 link = ((p0 >> 24) & 0x7FFFF) << 3;
 382         uint32 ptr = ((p0 >> 43) & 0x1FFFFF) << 3;
 383         uint32 firstPix = (p1 >> 49) & 0x3F;
 384         uint8 flags = (p1 >> 45) & 0x0F;
 385         uint8 idx = (p1 >> 38) & 0x7F;
 386         uint32 pitch = (p1 >> 15) & 0x07;
 387 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",
 388         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);
 389 }
 390 if ((p0 & 0x07) == OBJECT_TYPE_SCALE)
 391 {
 392 WriteLog(" (SCALED BITMAP)");
 393 uint64 p1 = OPLoadPhrase(op_pointer), p2 = OPLoadPhrase(op_pointer+8);
 394 WriteLog("\n%08X --> phrase %08X %08X ", op_pointer, (int)(p1>>32), (int)(p1&0xFFFFFFFF));
 395 WriteLog("\n%08X --> phrase %08X %08X ", op_pointer+8, (int)(p2>>32), (int)(p2&0xFFFFFFFF));
 396         uint8 bitdepth = (p1 >> 12) & 0x07;
 397 //WAS:  int16 ypos = ((p0 >> 3) & 0x3FF);                       // ??? What if not interlaced (/2)?
 398         int16 ypos = ((p0 >> 3) & 0x7FF);                       // ??? What if not interlaced (/2)?
 399 int32 xpos = p1 & 0xFFF;
 400 xpos = (xpos & 0x800 ? xpos | 0xFFFFF000 : xpos);
 401         uint32 iwidth = ((p1 >> 28) & 0x3FF);
 402         uint32 dwidth = ((p1 >> 18) & 0x3FF);           // Unsigned!
 403         uint16 height = ((p0 >> 14) & 0x3FF);
 404         uint32 link = ((p0 >> 24) & 0x7FFFF) << 3;
 405         uint32 ptr = ((p0 >> 43) & 0x1FFFFF) << 3;
 406         uint32 firstPix = (p1 >> 49) & 0x3F;
 407         uint8 flags = (p1 >> 45) & 0x0F;
 408         uint8 idx = (p1 >> 38) & 0x7F;
 409         uint32 pitch = (p1 >> 15) & 0x07;
 410 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",
 411         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);
 412         uint32 hscale = p2 & 0xFF;
 413         uint32 vscale = (p2 >> 8) & 0xFF;
 414         uint32 remainder = (p2 >> 16) & 0xFF;
 415 WriteLog("    [hsc: %02X, vsc: %02X, rem: %02X]\n", hscale, vscale, remainder);
 416 }
 417 if ((p0 & 0x07) == OBJECT_TYPE_GPU)
 418 WriteLog(" (GPU)\n");
 419 if ((p0 & 0x07) == OBJECT_TYPE_BRANCH)
 420 {
 421 WriteLog(" (BRANCH)\n");
 422 uint8 * jaguarMainRam = GetRamPtr();
 423 WriteLog("[RAM] --> ");
 424 for(int k=0; k<8; k++)
 425         WriteLog("%02X ", jaguarMainRam[op_pointer-8 + k]);
 426 WriteLog("\n");
 427 }
 428 if ((p0 & 0x07) == OBJECT_TYPE_STOP)
 429 WriteLog("    --> List end\n\n");
 430 }
 431 #endif
 432
 433                 switch ((uint8)p0 & 0x07)
 434                 {
 435                 case OBJECT_TYPE_BITMAP:
 436                 {
 437 //WAS:                  uint16 ypos = (p0 >> 3) & 0x3FF;
 438                         uint16 ypos = (p0 >> 3) & 0x7FF;
 439 // This is only theory implied by Rayman...!
 440 // It seems that if the YPOS is zero, then bump the YPOS value so that it coincides with
 441 // the VDB value. With interlacing, this would be slightly more tricky.
 442 // There's probably another bit somewhere that enables this mode--but so far, doesn't seem
 443 // to affect any other game in a negative way (that I've seen).
 444 // Either that, or it's an undocumented bug...
 445
 446 //No, the reason this was needed is that the OP code before was wrong. Any value
 447 //less than VDB will get written to the top line of the display!
 448 #if 0
 449 // Not so sure... Let's see what happens here...
 450 // No change...
 451                         if (ypos == 0)
 452                                 ypos = TOMReadWord(0xF00046, OP) / 2;                   // Get the VDB value
 453 #endif
 454 // Actually, no. Any item less than VDB will get only the lines that hang over VDB displayed.
 455 // Actually, this is incorrect. It seems that VDB value is wrong somewhere and that's
 456 // what's causing things to fuck up. Still no idea why.
 457
 458                         uint32 height = (p0 & 0xFFC000) >> 14;
 459                         uint32 oldOPP = op_pointer - 8;
 460 // *** BEGIN OP PROCESSOR TESTING ONLY ***
 461 if (inhibit && op_start_log)
 462         WriteLog("!!! ^^^ This object is INHIBITED! ^^^ !!!\n");
 463 bitmapCounter++;
 464 if (!inhibit)   // For OP testing only!
 465 // *** END OP PROCESSOR TESTING ONLY ***
 466                         if (scanline >= ypos && height > 0)
 467                         {
 468                                 uint64 p1 = OPLoadPhrase(op_pointer);
 469                                 op_pointer += 8;
 470 //WriteLog("OP: Writing scanline %d with ypos == %d...\n", scanline, ypos);
 471 //WriteLog("--> Writing %u BPP bitmap...\n", op_bitmap_bit_depth[(p1 >> 12) & 0x07]);
 472 //                              OPProcessFixedBitmap(scanline, p0, p1, render);
 473                                 OPProcessFixedBitmap(p0, p1, render);
 474
 475                                 // OP write-backs
 476
 477 //???Does this really happen??? Doesn't seem to work if you do this...!
 478 //Probably not. Must be a bug in the documentation...!
 479 //                              uint32 link = (p0 & 0x7FFFF000000) >> 21;
 480 //                              SET16(tom_ram_8, 0x20, link & 0xFFFF);  // OLP
 481 //                              SET16(tom_ram_8, 0x22, link >> 16);
 482 /*                              uint32 height = (p0 & 0xFFC000) >> 14;
 483                                 if (height - 1 > 0)
 484                                         height--;*/
 485                                 // NOTE: Would subtract 2 if in interlaced mode...!
 486 //                              uint64 height = ((p0 & 0xFFC000) - 0x4000) & 0xFFC000;
 487 //                              if (height)
 488                                 height--;
 489
 490                                 uint64 data = (p0 & 0xFFFFF80000000000LL) >> 40;
 491                                 uint64 dwidth = (p1 & 0xFFC0000) >> 15;
 492                                 data += dwidth;
 493
 494                                 p0 &= ~0xFFFFF80000FFC000LL;            // Mask out old data...
 495                                 p0 |= (uint64)height << 14;
 496                                 p0 |= data << 40;
 497                                 OPStorePhrase(oldOPP, p0);
 498                         }
 499 //WriteLog("\t\tOld OP: %08X -> ", op_pointer);
 500 //Temp, for testing...
 501 //No doubt, this type of check will break all kinds of stuff... !!! FIX !!!
 502 //And it does! !!! FIX !!!
 503 //Let's remove this "fix" since it screws up more than it fixes.
 504 /*      if (op_pointer > ((p0 & 0x000007FFFF000000LL) >> 21))
 505                 return;*/
 506
 507                         op_pointer = (p0 & 0x000007FFFF000000LL) >> 21;
 508 //WriteLog("New OP: %08X\n", op_pointer);
 509                         break;
 510                 }
 511                 case OBJECT_TYPE_SCALE:
 512                 {
 513 //WAS:                  uint16 ypos = (p0 >> 3) & 0x3FF;
 514                         uint16 ypos = (p0 >> 3) & 0x7FF;
 515                         uint32 height = (p0 & 0xFFC000) >> 14;
 516                         uint32 oldOPP = op_pointer - 8;
 517 //WriteLog("OP: Scaled Object (ypos=%04X, height=%04X", ypos, height);
 518 // *** BEGIN OP PROCESSOR TESTING ONLY ***
 519 if (inhibit && op_start_log)
 520 {
 521         WriteLog("!!! ^^^ This object is INHIBITED! ^^^ !!! (scanline=%u, ypos=%u, height=%u)\n", scanline, ypos, height);
 522         DumpScaledObject(p0, OPLoadPhrase(op_pointer), OPLoadPhrase(op_pointer+8));
 523 }
 524 bitmapCounter++;
 525 if (!inhibit)   // For OP testing only!
 526 // *** END OP PROCESSOR TESTING ONLY ***
 527                         if (scanline >= ypos && height > 0)
 528                         {
 529                                 uint64 p1 = OPLoadPhrase(op_pointer);
 530                                 op_pointer += 8;
 531                                 uint64 p2 = OPLoadPhrase(op_pointer);
 532                                 op_pointer += 8;
 533 //WriteLog("OP: %08X (%d) %08X%08X %08X%08X %08X%08X\n", oldOPP, scanline, (uint32)(p0>>32), (uint32)(p0&0xFFFFFFFF), (uint32)(p1>>32), (uint32)(p1&0xFFFFFFFF), (uint32)(p2>>32), (uint32)(p2&0xFFFFFFFF));
 534                                 OPProcessScaledBitmap(p0, p1, p2, render);
 535
 536                                 // OP write-backs
 537
 538                                 uint16 remainder = (p2 >> 16) & 0xFF;//, vscale = p2 >> 8;
 539                                 uint8 /*remainder = p2 >> 16,*/ vscale = p2 >> 8;
 540 //Actually, we should skip this object if it has a vscale of zero.
 541 //Or do we? Not sure... Atari Karts has a few lines that look like:
 542 // (SCALED BITMAP)
 543 //000E8268 --> phrase 00010000 7000B00D
 544 //    [7 (0) x 1 @ (13, 0) (8 bpp), l: 000E82A0, p: 000E0FC0 fp: 00, fl:RELEASE, idx:00, pt:01]
 545 //    [hsc: 9A, vsc: 00, rem: 00]
 546 // Could it be the vscale is overridden if the DWIDTH is zero? Hmm...
 547 //WriteLog("OP: Scaled bitmap processing (rem=%02X, vscale=%02X)...\n", remainder, vscale);//*/
 548
 549                                 if (vscale == 0)
 550                                         vscale = 0x20;                                  // OP bug??? Nope, it isn't...! Or is it?
 551
 552 //extern int start_logging;
 553 //if (start_logging)
 554 //      WriteLog("--> Returned from scaled bitmap processing (rem=%02X, vscale=%02X)...\n", remainder, vscale);//*/
 555 //Locks up here:
 556 //--> Returned from scaled bitmap processing (rem=20, vscale=80)...
 557 //There are other problems here, it looks like...
 558 //Another lock up:
 559 //About to execute OP (508)...
 560 /*
 561 OP: Scaled bitmap 4x? 4bpp at 38,? hscale=7C fpix=0 data=00075E28 pitch 1 hflipped=no dwidth=? (linked to 00071118) Transluency=no
 562 --> Returned from scaled bitmap processing (rem=50, vscale=7C)...
 563 OP: Scaled bitmap 4x? 4bpp at 38,? hscale=7C fpix=0 data=00075E28 pitch 1 hflipped=no dwidth=? (linked to 00071118) Transluency=no
 564 --> Returned from scaled bitmap processing (rem=30, vscale=7C)...
 565 OP: Scaled bitmap 4x? 4bpp at 38,? hscale=7C fpix=0 data=00075E28 pitch 1 hflipped=no dwidth=? (linked to 00071118) Transluency=no
 566 --> Returned from scaled bitmap processing (rem=10, vscale=7C)...
 567 OP: Scaled bitmap 4x? 4bpp at 36,? hscale=7E fpix=0 data=000756A8 pitch 1 hflipped=no dwidth=? (linked to 00073058) Transluency=no
 568 --> Returned from scaled bitmap processing (rem=00, vscale=7E)...
 569 OP: Scaled bitmap 4x? 4bpp at 34,? hscale=80 fpix=0 data=000756C8 pitch 1 hflipped=no dwidth=? (linked to 00073078) Transluency=no
 570 --> Returned from scaled bitmap processing (rem=00, vscale=80)...
 571 OP: Scaled bitmap 4x? 4bpp at 36,? hscale=7E fpix=0 data=000756C8 pitch 1 hflipped=no dwidth=? (linked to 00073058) Transluency=no
 572 --> Returned from scaled bitmap processing (rem=5E, vscale=7E)...
 573 OP: Scaled bitmap 4x? 4bpp at 34,? hscale=80 fpix=0 data=000756E8 pitch 1 hflipped=no dwidth=? (linked to 00073078) Transluency=no
 574 --> Returned from scaled bitmap processing (rem=60, vscale=80)...
 575 OP: Scaled bitmap 4x? 4bpp at 36,? hscale=7E fpix=0 data=000756C8 pitch 1 hflipped=no dwidth=? (linked to 00073058) Transluency=no
 576 --> Returned from scaled bitmap processing (rem=3E, vscale=7E)...
 577 OP: Scaled bitmap 4x? 4bpp at 34,? hscale=80 fpix=0 data=000756E8 pitch 1 hflipped=no dwidth=? (linked to 00073078) Transluency=no
 578 --> Returned from scaled bitmap processing (rem=40, vscale=80)...
 579 OP: Scaled bitmap 4x? 4bpp at 36,? hscale=7E fpix=0 data=000756C8 pitch 1 hflipped=no dwidth=? (linked to 00073058) Transluency=no
 580 --> Returned from scaled bitmap processing (rem=1E, vscale=7E)...
 581 OP: Scaled bitmap 4x? 4bpp at 34,? hscale=80 fpix=0 data=000756E8 pitch 1 hflipped=no dwidth=? (linked to 00073078) Transluency=no
 582 --> Returned from scaled bitmap processing (rem=20, vscale=80)...
 583 */
 584 //Here's another problem:
 585 //    [hsc: 20, vsc: 20, rem: 00]
 586 // Since we're not checking for $E0 (but that's what we get from the above), we end
 587 // up repeating this scanline unnecessarily... !!! FIX !!! [DONE, but... still not quite
 588 // right. Either that, or the Accolade team that wrote Bubsy screwed up royal.]
 589 //Also note: $E0 = 7.0 which IS a legal vscale value...
 590
 591 //                              if (remainder & 0x80)                           // I.e., it's negative
 592 //                              if ((remainder & 0x80) || remainder == 0)       // I.e., it's <= 0
 593 //                              if ((remainder - 1) >= 0xE0)            // I.e., it's <= 0
 594 //                              if ((remainder >= 0xE1) || remainder == 0)// I.e., it's <= 0
 595 //                              if ((remainder >= 0xE1 && remainder <= 0xFF) || remainder == 0)// I.e., it's <= 0
 596 //                              if (remainder <= 0x20)                          // I.e., it's <= 1.0
 597                                 // I.e., it's < 1.0f -> means it'll go negative when we subtract 1.0f.
 598                                 if (remainder < 0x20)
 599                                 {
 600                                         uint64 data = (p0 & 0xFFFFF80000000000LL) >> 40;
 601                                         uint64 dwidth = (p1 & 0xFFC0000) >> 15;
 602
 603 //                                      while (remainder & 0x80)
 604 //                                      while ((remainder & 0x80) || remainder == 0)
 605 //                                      while ((remainder - 1) >= 0xE0)
 606 //                                      while ((remainder >= 0xE1) || remainder == 0)
 607 //                                      while ((remainder >= 0xE1 && remainder <= 0xFF) || remainder == 0)
 608 //                                      while (remainder <= 0x20)
 609                                         while (remainder < 0x20)
 610                                         {
 611                                                 remainder += vscale;
 612
 613                                                 if (height)
 614                                                         height--;
 615
 616                                                 data += dwidth;
 617                                         }
 618
 619                                         p0 &= ~0xFFFFF80000FFC000LL;    // Mask out old data...
 620                                         p0 |= (uint64)height << 14;
 621                                         p0 |= data << 40;
 622                                         OPStorePhrase(oldOPP, p0);
 623                                 }
 624
 625                                 remainder -= 0x20;                                      // 1.0f in [3.5] fixed point format
 626
 627 //if (start_logging)
 628 //      WriteLog("--> Finished writebacks...\n");//*/
 629
 630 //WriteLog(" [%08X%08X -> ", (uint32)(p2>>32), (uint32)(p2&0xFFFFFFFF));
 631                                 p2 &= ~0x0000000000FF0000LL;
 632                                 p2 |= (uint64)remainder << 16;
 633 //WriteLog("%08X%08X]\n", (uint32)(p2>>32), (uint32)(p2&0xFFFFFFFF));
 634                                 OPStorePhrase(oldOPP + 16, p2);
 635 //remainder = (uint8)(p2 >> 16), vscale = (uint8)(p2 >> 8);
 636 //WriteLog(" [after]: rem=%02X, vscale=%02X\n", remainder, vscale);
 637                         }
 638
 639                         op_pointer = (p0 & 0x000007FFFF000000LL) >> 21;
 640                         break;
 641                 }
 642                 case OBJECT_TYPE_GPU:
 643                 {
 644 //WriteLog("OP: Asserting GPU IRQ #3...\n");
 645 #warning "Need to fix OP GPU IRQ handling! !!! FIX !!!"
 646                         OPSetCurrentObject(p0);
 647                         GPUSetIRQLine(3, ASSERT_LINE);
 648 //Also, OP processing is suspended from this point until OBF (F00026) is written to...
 649 // !!! FIX !!!
 650 //Do something like:
 651 //OPSuspendedByGPU = true;
 652 //Dunno if the OP keeps processing from where it was interrupted, or if it just continues
 653 //on the next scanline...
 654 // --> It continues from where it was interrupted! !!! FIX !!!
 655                         break;
 656                 }
 657                 case OBJECT_TYPE_BRANCH:
 658                 {
 659                         uint16 ypos = (p0 >> 3) & 0x7FF;
 660                         uint8  cc   = (p0 >> 14) & 0x03;
 661                         uint32 link = (p0 >> 21) & 0x3FFFF8;
 662
 663 //                      if ((ypos!=507)&&(ypos!=25))
 664 //                              WriteLog("\t%i%s%i link=0x%.8x\n",scanline,condition_to_str[cc],ypos>>1,link);
 665                         switch (cc)
 666                         {
 667                         case CONDITION_EQUAL:
 668                                 if (TOMReadWord(0xF00006, OP) == ypos || ypos == 0x7FF)
 669                                         op_pointer = link;
 670                                 break;
 671                         case CONDITION_LESS_THAN:
 672                                 if (TOMReadWord(0xF00006, OP) < ypos)
 673                                         op_pointer = link;
 674                                 break;
 675                         case CONDITION_GREATER_THAN:
 676                                 if (TOMReadWord(0xF00006, OP) > ypos)
 677                                         op_pointer = link;
 678                                 break;
 679                         case CONDITION_OP_FLAG_SET:
 680                                 if (OPGetStatusRegister() & 0x01)
 681                                         op_pointer = link;
 682                                 break;
 683                         case CONDITION_SECOND_HALF_LINE:
 684 //Here's the ASIC code:
 685 //  ND4(cctrue5, newheight[2], heightl[1], heightl[0], hcb[10]);
 686 //which means, do the link if bit 10 of HC is set...
 687
 688                                 // This basically means branch if bit 10 of HC is set
 689 #warning "Unhandled condition code causes emulator to crash... !!! FIX !!!"
 690                                 WriteLog("OP: Unexpected CONDITION_SECOND_HALF_LINE in BRANCH object\nOP: shutting down!\n");
 691                                 LogDone();
 692                                 exit(0);
 693                                 break;
 694                         default:
 695                                 WriteLog("OP: Unimplemented branch condition %i\n", cc);
 696                         }
 697                         break;
 698                 }
 699                 case OBJECT_TYPE_STOP:
 700                 {
 701 //op_start_log = 0;
 702                         // unsure
 703 //WriteLog("OP: --> STOP\n");
 704 //                      op_set_status_register(((p0>>3) & 0xFFFFFFFF));
 705 //This seems more likely...
 706                         OPSetCurrentObject(p0);
 707
 708                         if (p0 & 0x08)
 709                         {
 710                                 // We need to check whether these interrupts are enabled or not, THEN
 711                                 // set an IRQ + pending flag if necessary...
 712                                 if (TOMIRQEnabled(IRQ_OPFLAG))
 713                                 {
 714                                         TOMSetPendingObjectInt();
 715                                         m68k_set_irq(2);                                // Cause a 68K IPL 2 to occur...
 716                                 }
 717                         }
 718
 719                         return;
 720 //                      break;
 721                 }
 722                 default:
 723                         WriteLog("op: unknown object type %i\n", ((uint8)p0 & 0x07));
 724                         return;
 725                 }
 726
 727                 // Here is a little sanity check to keep the OP from locking up the machine
 728                 // when fed bad data. Better would be to count how many actual cycles it used
 729                 // and bail out/reenter to properly simulate an overloaded OP... !!! FIX !!!
 730 #warning "Better would be to count how many actual cycles it used and bail out/reenter to properly simulate an overloaded OP... !!! FIX !!!"
 731                 opCyclesToRun--;
 732                 if (!opCyclesToRun)
 733                         return;
 734         }
 735 }
 736
 737 //
 738 // Store fixed size bitmap in line buffer
 739 //
 740 void OPProcessFixedBitmap(uint64 p0, uint64 p1, bool render)
 741 {
 742 // Need to make sure that when writing that it stays within the line buffer...
 743 // LBUF ($F01800 - $F01D9E) 360 x 32-bit RAM
 744         uint8 depth = (p1 >> 12) & 0x07;                                // Color depth of image
 745         int32 xpos = ((int16)((p1 << 4) & 0xFFFF)) >> 4;// Image xpos in LBUF
 746         uint32 iwidth = (p1 >> 28) & 0x3FF;                             // Image width in *phrases*
 747         uint32 data = (p0 >> 40) & 0xFFFFF8;                    // Pixel data address
 748 //#ifdef OP_DEBUG_BMP
 749         uint32  firstPix = (p1 >> 49) & 0x3F;
 750         // "The LSB is significant only for scaled objects..." -JTRM
 751         // "In 1 BPP mode, all five bits are significant. In 2 BPP mode, the top four are significant..."
 752         firstPix &= 0x3E;
 753 //#endif
 754 // We can ignore the RELEASE (high order) bit for now--probably forever...!
 755 //      uint8 flags = (p1 >> 45) & 0x0F;        // REFLECT, RMW, TRANS, RELEASE
 756 //Optimize: break these out to their own BOOL values
 757         uint8 flags = (p1 >> 45) & 0x07;                                // REFLECT (0), RMW (1), TRANS (2)
 758         bool flagREFLECT = (flags & OPFLAG_REFLECT ? true : false),
 759                 flagRMW = (flags & OPFLAG_RMW ? true : false),
 760                 flagTRANS = (flags & OPFLAG_TRANS ? true : false);
 761 // "For images with 1 to 4 bits/pixel the top 7 to 4 bits of the index
 762 //  provide the most significant bits of the palette address."
 763         uint8 index = (p1 >> 37) & 0xFE;                                // CLUT index offset (upper pix, 1-4 bpp)
 764         uint32 pitch = (p1 >> 15) & 0x07;                               // Phrase pitch
 765         pitch <<= 3;                                                                    // Optimization: Multiply pitch by 8
 766
 767 //      int16 scanlineWidth = tom_getVideoModeWidth();
 768         uint8 * tomRam8 = TOMGetRamPointer();
 769         uint8 * paletteRAM = &tomRam8[0x400];
 770         // This is OK as long as it's used correctly: For 16-bit RAM to RAM direct copies--NOT
 771         // for use when using endian-corrected data (i.e., any of the *_word_read functions!)
 772         uint16 * paletteRAM16 = (uint16 *)paletteRAM;
 773
 774 //      WriteLog("bitmap %ix? %ibpp at %i,? firstpix=? data=0x%.8x pitch %i hflipped=%s dwidth=? (linked to ?) RMW=%s Tranparent=%s\n",
 775 //              iwidth, op_bitmap_bit_depth[bitdepth], xpos, ptr, pitch, (flags&OPFLAG_REFLECT ? "yes" : "no"), (flags&OPFLAG_RMW ? "yes" : "no"), (flags&OPFLAG_TRANS ? "yes" : "no"));
 776
 777 // Is it OK to have a 0 for the data width??? (i.e., undocumented?)
 778 // Seems to be... Seems that dwidth *can* be zero (i.e., reuse same line) as well.
 779 // Pitch == 0 is OK too...
 780 //      if (!render || op_pointer == 0 || ptr == 0 || pitch == 0)
 781 //I'm not convinced that we need to concern ourselves with data & op_pointer here either!
 782         if (!render || iwidth == 0)
 783                 return;
 784
 785 //#define OP_DEBUG_BMP
 786 //#ifdef OP_DEBUG_BMP
 787 //      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",
 788 //              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"));
 789 //#endif
 790
 791 //      int32 leftMargin = xpos, rightMargin = (xpos + (phraseWidthToPixels[depth] * iwidth)) - 1;
 792         int32 startPos = xpos, endPos = xpos +
 793                 (!flagREFLECT ? (phraseWidthToPixels[depth] * iwidth) - 1
 794                 : -((phraseWidthToPixels[depth] * iwidth) + 1));
 795         uint32 clippedWidth = 0, phraseClippedWidth = 0, dataClippedWidth = 0;//, phrasePixel = 0;
 796         bool in24BPPMode = (((GET16(tomRam8, 0x0028) >> 1) & 0x03) == 1 ? true : false);        // VMODE
 797         // Not sure if this is Jaguar Two only location or what...
 798         // From the docs, it is... If we want to limit here we should think of something else.
 799 //      int32 limit = GET16(tom_ram_8, 0x0008);                 // LIMIT
 800         int32 limit = 720;
 801         int32 lbufWidth = (!in24BPPMode ? limit - 1 : (limit / 2) - 1); // Zero based limit...
 802
 803         // If the image is completely to the left or right of the line buffer, then bail.
 804 //If in REFLECT mode, then these values are swapped! !!! FIX !!! [DONE]
 805 //There are four possibilities:
 806 //  1. image sits on left edge and no REFLECT; starts out of bounds but ends in bounds.
 807 //  2. image sits on left edge and REFLECT; starts in bounds but ends out of bounds.
 808 //  3. image sits on right edge and REFLECT; starts out of bounds but ends in bounds.
 809 //  4. image sits on right edge and no REFLECT; starts in bounds but ends out of bounds.
 810 //Numbers 2 & 4 can be caught by checking the LBUF clip while in the inner loop,
 811 // numbers 1 & 3 are of concern.
 812 // This *indirectly* handles only cases 2 & 4! And is WRONG is REFLECT is set...!
 813 //      if (rightMargin < 0 || leftMargin > lbufWidth)
 814
 815 // It might be easier to swap these (if REFLECTed) and just use XPOS down below...
 816 // That way, you could simply set XPOS to leftMargin if !REFLECT and to rightMargin otherwise.
 817 // Still have to be careful with the DATA and IWIDTH values though...
 818
 819 //      if ((!flagREFLECT && (rightMargin < 0 || leftMargin > lbufWidth))
 820 //              || (flagREFLECT && (leftMargin < 0 || rightMargin > lbufWidth)))
 821 //              return;
 822         if ((!flagREFLECT && (endPos < 0 || startPos > lbufWidth))
 823                 || (flagREFLECT && (startPos < 0 || endPos > lbufWidth)))
 824                 return;
 825
 826         // Otherwise, find the clip limits and clip the phrase as well...
 827         // NOTE: I'm fudging here by letting the actual blit overstep the bounds of the
 828         //       line buffer, but it shouldn't matter since there are two unused line
 829         //       buffers below and nothing above and I'll at most write 8 bytes outside
 830         //       the line buffer... I could use a fractional clip begin/end value, but
 831         //       this makes the blit a *lot* more hairy. I might fix this in the future
 832         //       if it becomes necessary. (JLH)
 833         //       Probably wouldn't be *that* hairy. Just use a delta that tells the inner loop
 834         //       which pixel in the phrase is being written, and quit when either end of phrases
 835         //       is reached or line buffer extents are surpassed.
 836
 837 //This stuff is probably wrong as well... !!! FIX !!!
 838 //The strange thing is that it seems to work, but that's no guarantee that it's bulletproof!
 839 //Yup. Seems that JagMania doesn't work correctly with this...
 840 //Dunno if this is the problem, but Atari Karts is showing *some* of the road now...
 841 //      if (!flagREFLECT)
 842
 843 /*
 844         if (leftMargin < 0)
 845                 clippedWidth = 0 - leftMargin,
 846                 phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth],
 847                 leftMargin = 0 - (clippedWidth % phraseWidthToPixels[depth]);
 848 //              leftMargin = 0;
 849
 850         if (rightMargin > lbufWidth)
 851                 clippedWidth = rightMargin - lbufWidth,
 852                 phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth];//,
 853 //              rightMargin = lbufWidth + (clippedWidth % phraseWidthToPixels[depth]);
 854 //              rightMargin = lbufWidth;
 855 */
 856 if (depth > 5)
 857         WriteLog("OP: We're about to encounter a divide by zero error!\n");
 858         // NOTE: We're just using endPos to figure out how much, if any, to clip by.
 859         // ALSO: There may be another case where we start out of bounds and end out of bounds...!
 860         // !!! FIX !!!
 861         if (startPos < 0)                       // Case #1: Begin out, end in, L to R
 862                 clippedWidth = 0 - startPos,
 863                 dataClippedWidth = phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth],
 864                 startPos = 0 - (clippedWidth % phraseWidthToPixels[depth]);
 865
 866         if (endPos < 0)                         // Case #2: Begin in, end out, R to L
 867                 clippedWidth = 0 - endPos,
 868                 phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth];
 869
 870         if (endPos > lbufWidth)         // Case #3: Begin in, end out, L to R
 871                 clippedWidth = endPos - lbufWidth,
 872                 phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth];
 873
 874         if (startPos > lbufWidth)       // Case #4: Begin out, end in, R to L
 875                 clippedWidth = startPos - lbufWidth,
 876                 dataClippedWidth = phraseClippedWidth = clippedWidth / phraseWidthToPixels[depth],
 877                 startPos = lbufWidth + (clippedWidth % phraseWidthToPixels[depth]);
 878
 879         // If the image is sitting on the line buffer left or right edge, we need to compensate
 880         // by decreasing the image phrase width accordingly.
 881         iwidth -= phraseClippedWidth;
 882
 883         // Also, if we're clipping the phrase we need to make sure we're in the correct part of
 884         // the pixel data.
 885 //      data += phraseClippedWidth * (pitch << 3);
 886         data += dataClippedWidth * pitch;
 887
 888         // NOTE: When the bitmap is in REFLECT mode, the XPOS marks the *right* side of the
 889         //       bitmap! This makes clipping & etc. MUCH, much easier...!
 890 //      uint32 lbufAddress = 0x1800 + (!in24BPPMode ? leftMargin * 2 : leftMargin * 4);
 891 //Why does this work right when multiplying startPos by 2 (instead of 4) for 24 BPP mode?
 892 //Is this a bug in the OP?
 893         uint32 lbufAddress = 0x1800 + (!in24BPPMode ? startPos * 2 : startPos * 2);
 894         uint8 * currentLineBuffer = &tomRam8[lbufAddress];
 895
 896         // Render.
 897
 898 // Hmm. We check above for 24 BPP mode, but don't do anything about it below...
 899 // If we *were* in 24 BPP mode, how would you convert CRY to RGB24? Seems to me
 900 // that if you're in CRY mode then you wouldn't be able to use 24 BPP bitmaps
 901 // anyway.
 902 // This seems to be the case (at least according to the Midsummer docs)...!
 903
 904 // This is to test using palette zeroes instead of bit zeroes...
 905 // And it seems that this is wrong, index == 0 is transparent apparently... :-/
 906 //#define OP_USES_PALETTE_ZERO
 907
 908         if (depth == 0)                                                                 // 1 BPP
 909         {
 910                 // The LSB of flags is OPFLAG_REFLECT, so sign extend it and or 2 into it.
 911                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
 912
 913                 // Fetch 1st phrase...
 914                 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
 915 //Note that firstPix should only be honored *if* we start with the 1st phrase of the bitmap
 916 //i.e., we didn't clip on the margin... !!! FIX !!!
 917                 pixels <<= firstPix;                                            // Skip first N pixels (N=firstPix)...
 918                 int i = firstPix;                                                       // Start counter at right spot...
 919
 920                 while (iwidth--)
 921                 {
 922                         while (i++ < 64)
 923                         {
 924                                 uint8 bit = pixels >> 63;
 925 #ifndef OP_USES_PALETTE_ZERO
 926                                 if (flagTRANS && bit == 0)
 927 #else
 928                                 if (flagTRANS && (paletteRAM16[index | bit] == 0))
 929 #endif
 930                                         ;       // Do nothing...
 931                                 else
 932                                 {
 933                                         if (!flagRMW)
 934 //Optimize: Set palleteRAM16 to beginning of palette RAM + index*2 and use only [bit] as index...
 935 //Won't optimize RMW case though...
 936                                                 // This is the *only* correct use of endian-dependent code
 937                                                 // (i.e., mem-to-mem direct copying)!
 938                                                 *(uint16 *)currentLineBuffer = paletteRAM16[index | bit];
 939                                         else
 940                                                 *currentLineBuffer =
 941                                                         BLEND_CR(*currentLineBuffer, paletteRAM[(index | bit) << 1]),
 942                                                 *(currentLineBuffer + 1) =
 943                                                         BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bit) << 1) + 1]);
 944                                 }
 945
 946                                 currentLineBuffer += lbufDelta;
 947                                 pixels <<= 1;
 948                         }
 949                         i = 0;
 950                         // Fetch next phrase...
 951                         data += pitch;
 952                         pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
 953                 }
 954         }
 955         else if (depth == 1)                                                    // 2 BPP
 956         {
 957 if (firstPix)
 958         WriteLog("OP: Fixed bitmap @ 2 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
 959                 index &= 0xFC;                                                          // Top six bits form CLUT index
 960                 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
 961                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
 962
 963                 while (iwidth--)
 964                 {
 965                         // Fetch phrase...
 966                         uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
 967                         data += pitch;
 968
 969                         for(int i=0; i<32; i++)
 970                         {
 971                                 uint8 bits = pixels >> 62;
 972 // Seems to me that both of these are in the same endian, so we could cast it as
 973 // uint16 * and do straight across copies (what about 24 bpp? Treat it differently...)
 974 // This only works for the palettized modes (1 - 8 BPP), since we actually have to
 975 // copy data from memory in 16 BPP mode (or does it? Isn't this the same as the CLUT case?)
 976 // No, it isn't because we read the memory in an endian safe way--this *won't* work...
 977 #ifndef OP_USES_PALETTE_ZERO
 978                                 if (flagTRANS && bits == 0)
 979 #else
 980                                 if (flagTRANS && (paletteRAM16[index | bits] == 0))
 981 #endif
 982                                         ;       // Do nothing...
 983                                 else
 984                                 {
 985                                         if (!flagRMW)
 986                                                 *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
 987                                         else
 988                                                 *currentLineBuffer =
 989                                                         BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
 990                                                 *(currentLineBuffer + 1) =
 991                                                         BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
 992                                 }
 993
 994                                 currentLineBuffer += lbufDelta;
 995                                 pixels <<= 2;
 996                         }
 997                 }
 998         }
 999         else if (depth == 2)                                                    // 4 BPP
1000         {
1001 if (firstPix)
1002         WriteLog("OP: Fixed bitmap @ 4 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1003                 index &= 0xF0;                                                          // Top four bits form CLUT index
1004                 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1005                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1006
1007                 while (iwidth--)
1008                 {
1009                         // Fetch phrase...
1010                         uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1011                         data += pitch;
1012
1013                         for(int i=0; i<16; i++)
1014                         {
1015                                 uint8 bits = pixels >> 60;
1016 // Seems to me that both of these are in the same endian, so we could cast it as
1017 // uint16 * and do straight across copies (what about 24 bpp? Treat it differently...)
1018 // This only works for the palettized modes (1 - 8 BPP), since we actually have to
1019 // copy data from memory in 16 BPP mode (or does it? Isn't this the same as the CLUT case?)
1020 // No, it isn't because we read the memory in an endian safe way--this *won't* work...
1021 #ifndef OP_USES_PALETTE_ZERO
1022                                 if (flagTRANS && bits == 0)
1023 #else
1024                                 if (flagTRANS && (paletteRAM16[index | bits] == 0))
1025 #endif
1026                                         ;       // Do nothing...
1027                                 else
1028                                 {
1029                                         if (!flagRMW)
1030                                                 *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1031                                         else
1032                                                 *currentLineBuffer =
1033                                                         BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1034                                                 *(currentLineBuffer + 1) =
1035                                                         BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1036                                 }
1037
1038                                 currentLineBuffer += lbufDelta;
1039                                 pixels <<= 4;
1040                         }
1041                 }
1042         }
1043         else if (depth == 3)                                                    // 8 BPP
1044         {
1045                 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1046                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1047
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                 firstPix &= 0x30;                                                       // Only top two bits are valid for 8 BPP
1053                 pixels <<= firstPix;                                            // Skip first N pixels (N=firstPix)...
1054                 int i = firstPix >> 3;                                          // Start counter at right spot...
1055
1056                 while (iwidth--)
1057                 {
1058                         while (i++ < 8)
1059                         {
1060                                 uint8 bits = pixels >> 56;
1061 // Seems to me that both of these are in the same endian, so we could cast it as
1062 // uint16 * and do straight across copies (what about 24 bpp? Treat it differently...)
1063 // This only works for the palettized modes (1 - 8 BPP), since we actually have to
1064 // copy data from memory in 16 BPP mode (or does it? Isn't this the same as the CLUT case?)
1065 // No, it isn't because we read the memory in an endian safe way--this *won't* work...
1066 //This would seem to be problematic...
1067 //Because it's the palette entry being zero that makes the pixel transparent...
1068 //Let's try it and see.
1069 #ifndef OP_USES_PALETTE_ZERO
1070                                 if (flagTRANS && bits == 0)
1071 #else
1072                                 if (flagTRANS && (paletteRAM16[bits] == 0))
1073 #endif
1074                                         ;       // Do nothing...
1075                                 else
1076                                 {
1077                                         if (!flagRMW)
1078                                                 *(uint16 *)currentLineBuffer = paletteRAM16[bits];
1079                                         else
1080                                                 *currentLineBuffer =
1081                                                         BLEND_CR(*currentLineBuffer, paletteRAM[bits << 1]),
1082                                                 *(currentLineBuffer + 1) =
1083                                                         BLEND_Y(*(currentLineBuffer + 1), paletteRAM[(bits << 1) + 1]);
1084                                 }
1085
1086                                 currentLineBuffer += lbufDelta;
1087                                 pixels <<= 8;
1088                         }
1089                         i = 0;
1090                         // Fetch next phrase...
1091                         data += pitch;
1092                         pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1093                 }
1094         }
1095         else if (depth == 4)                                                    // 16 BPP
1096         {
1097 if (firstPix)
1098         WriteLog("OP: Fixed bitmap @ 16 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1099                 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1100                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1101
1102                 while (iwidth--)
1103                 {
1104                         // Fetch phrase...
1105                         uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1106                         data += pitch;
1107
1108                         for(int i=0; i<4; i++)
1109                         {
1110                                 uint8 bitsHi = pixels >> 56, bitsLo = pixels >> 48;
1111 // Seems to me that both of these are in the same endian, so we could cast it as
1112 // uint16 * and do straight across copies (what about 24 bpp? Treat it differently...)
1113 // This only works for the palettized modes (1 - 8 BPP), since we actually have to
1114 // copy data from memory in 16 BPP mode (or does it? Isn't this the same as the CLUT case?)
1115 // No, it isn't because we read the memory in an endian safe way--it *won't* work...
1116 //This doesn't seem right... Let's try the encoded black value ($8800):
1117 //Apparently, CRY 0 maps to $8800...
1118                                 if (flagTRANS && ((bitsLo | bitsHi) == 0))
1119 //                              if (flagTRANS && (bitsHi == 0x88) && (bitsLo == 0x00))
1120                                         ;       // Do nothing...
1121                                 else
1122                                 {
1123                                         if (!flagRMW)
1124                                                 *currentLineBuffer = bitsHi,
1125                                                 *(currentLineBuffer + 1) = bitsLo;
1126                                         else
1127                                                 *currentLineBuffer =
1128                                                         BLEND_CR(*currentLineBuffer, bitsHi),
1129                                                 *(currentLineBuffer + 1) =
1130                                                         BLEND_Y(*(currentLineBuffer + 1), bitsLo);
1131                                 }
1132
1133                                 currentLineBuffer += lbufDelta;
1134                                 pixels <<= 16;
1135                         }
1136                 }
1137         }
1138         else if (depth == 5)                                                    // 24 BPP
1139         {
1140 //Looks like Iron Soldier is the only game that uses 24BPP mode...
1141 //There *might* be others...
1142 //WriteLog("OP: Writing 24 BPP bitmap!\n");
1143 if (firstPix)
1144         WriteLog("OP: Fixed bitmap @ 24 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1145                 // Not sure, but I think RMW only works with 16 BPP and below, and only in CRY mode...
1146                 // The LSB of flags is OPFLAG_REFLECT, so sign extend it and OR 4 into it.
1147                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 4) | 0x04;
1148
1149                 while (iwidth--)
1150                 {
1151                         // Fetch phrase...
1152                         uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1153                         data += pitch;
1154
1155                         for(int i=0; i<2; i++)
1156                         {
1157                                 // We don't use a 32-bit var here because of endian issues...!
1158                                 uint8 bits3 = pixels >> 56, bits2 = pixels >> 48,
1159                                         bits1 = pixels >> 40, bits0 = pixels >> 32;
1160
1161                                 if (flagTRANS && (bits3 | bits2 | bits1 | bits0) == 0)
1162                                         ;       // Do nothing...
1163                                 else
1164                                         *currentLineBuffer = bits3,
1165                                         *(currentLineBuffer + 1) = bits2,
1166                                         *(currentLineBuffer + 2) = bits1,
1167                                         *(currentLineBuffer + 3) = bits0;
1168
1169                                 currentLineBuffer += lbufDelta;
1170                                 pixels <<= 32;
1171                         }
1172                 }
1173         }
1174 }
1175
1176 //
1177 // Store scaled bitmap in line buffer
1178 //
1179 void OPProcessScaledBitmap(uint64 p0, uint64 p1, uint64 p2, bool render)
1180 {
1181 // Need to make sure that when writing that it stays within the line buffer...
1182 // LBUF ($F01800 - $F01D9E) 360 x 32-bit RAM
1183         uint8 depth = (p1 >> 12) & 0x07;                                // Color depth of image
1184         int32 xpos = ((int16)((p1 << 4) & 0xFFFF)) >> 4;// Image xpos in LBUF
1185         uint32 iwidth = (p1 >> 28) & 0x3FF;                             // Image width in *phrases*
1186         uint32 data = (p0 >> 40) & 0xFFFFF8;                    // Pixel data address
1187 //#ifdef OP_DEBUG_BMP
1188 // Prolly should use this... Though not sure exactly how.
1189 //Use the upper bits as an offset into the phrase depending on the BPP. That's how!
1190         uint32 firstPix = (p1 >> 49) & 0x3F;
1191 //This is WEIRD! I'm sure I saw Atari Karts request 8 BPP FIRSTPIX! What happened???
1192 if (firstPix)
1193         WriteLog("OP: FIRSTPIX != 0! (Scaled BM)\n");
1194 //#endif
1195 // We can ignore the RELEASE (high order) bit for now--probably forever...!
1196 //      uint8 flags = (p1 >> 45) & 0x0F;        // REFLECT, RMW, TRANS, RELEASE
1197 //Optimize: break these out to their own BOOL values [DONE]
1198         uint8 flags = (p1 >> 45) & 0x07;                                // REFLECT (0), RMW (1), TRANS (2)
1199         bool flagREFLECT = (flags & OPFLAG_REFLECT ? true : false),
1200                 flagRMW = (flags & OPFLAG_RMW ? true : false),
1201                 flagTRANS = (flags & OPFLAG_TRANS ? true : false);
1202         uint8 index = (p1 >> 37) & 0xFE;                                // CLUT index offset (upper pix, 1-4 bpp)
1203         uint32 pitch = (p1 >> 15) & 0x07;                               // Phrase pitch
1204
1205         uint8 * tomRam8 = TOMGetRamPointer();
1206         uint8 * paletteRAM = &tomRam8[0x400];
1207         // This is OK as long as it's used correctly: For 16-bit RAM to RAM direct copies--NOT
1208         // for use when using endian-corrected data (i.e., any of the *ReadWord functions!)
1209         uint16 * paletteRAM16 = (uint16 *)paletteRAM;
1210
1211         uint16 hscale = p2 & 0xFF;
1212 // Hmm. It seems that fixing the horizontal scale necessitated re-fixing this. Not sure why,
1213 // but seems to be consistent with the vertical scaling now (and it may turn out to be wrong!)...
1214         uint16 horizontalRemainder = hscale;                            // Not sure if it starts full, but seems reasonable [It's not!]
1215 //      uint8 horizontalRemainder = 0;                                  // Let's try zero! Seems to work! Yay! [No, it doesn't!]
1216         int32 scaledWidthInPixels = (iwidth * phraseWidthToPixels[depth] * hscale) >> 5;
1217         uint32 scaledPhrasePixels = (phraseWidthToPixels[depth] * hscale) >> 5;
1218
1219 //      WriteLog("bitmap %ix? %ibpp at %i,? firstpix=? data=0x%.8x pitch %i hflipped=%s dwidth=? (linked to ?) RMW=%s Tranparent=%s\n",
1220 //              iwidth, op_bitmap_bit_depth[bitdepth], xpos, ptr, pitch, (flags&OPFLAG_REFLECT ? "yes" : "no"), (flags&OPFLAG_RMW ? "yes" : "no"), (flags&OPFLAG_TRANS ? "yes" : "no"));
1221
1222 // Looks like an hscale of zero means don't draw!
1223         if (!render || iwidth == 0 || hscale == 0)
1224                 return;
1225
1226 /*extern int start_logging;
1227 if (start_logging)
1228         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",
1229                 iwidth, op_bitmap_bit_depth[depth], xpos, hscale, firstPix, data, pitch, (flagREFLECT ? "yes" : "no"), op_pointer, (flagRMW ? "yes" : "no"));*/
1230 //#define OP_DEBUG_BMP
1231 //#ifdef OP_DEBUG_BMP
1232 //      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",
1233 //              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"));
1234 //#endif
1235
1236         int32 startPos = xpos, endPos = xpos +
1237                 (!flagREFLECT ? scaledWidthInPixels - 1 : -(scaledWidthInPixels + 1));
1238         uint32 clippedWidth = 0, phraseClippedWidth = 0, dataClippedWidth = 0;
1239         bool in24BPPMode = (((GET16(tomRam8, 0x0028) >> 1) & 0x03) == 1 ? true : false);        // VMODE
1240         // Not sure if this is Jaguar Two only location or what...
1241         // From the docs, it is... If we want to limit here we should think of something else.
1242 //      int32 limit = GET16(tom_ram_8, 0x0008);                 // LIMIT
1243         int32 limit = 720;
1244         int32 lbufWidth = (!in24BPPMode ? limit - 1 : (limit / 2) - 1); // Zero based limit...
1245
1246         // If the image is completely to the left or right of the line buffer, then bail.
1247 //If in REFLECT mode, then these values are swapped! !!! FIX !!! [DONE]
1248 //There are four possibilities:
1249 //  1. image sits on left edge and no REFLECT; starts out of bounds but ends in bounds.
1250 //  2. image sits on left edge and REFLECT; starts in bounds but ends out of bounds.
1251 //  3. image sits on right edge and REFLECT; starts out of bounds but ends in bounds.
1252 //  4. image sits on right edge and no REFLECT; starts in bounds but ends out of bounds.
1253 //Numbers 2 & 4 can be caught by checking the LBUF clip while in the inner loop,
1254 // numbers 1 & 3 are of concern.
1255 // This *indirectly* handles only cases 2 & 4! And is WRONG if REFLECT is set...!
1256 //      if (rightMargin < 0 || leftMargin > lbufWidth)
1257
1258 // It might be easier to swap these (if REFLECTed) and just use XPOS down below...
1259 // That way, you could simply set XPOS to leftMargin if !REFLECT and to rightMargin otherwise.
1260 // Still have to be careful with the DATA and IWIDTH values though...
1261
1262         if ((!flagREFLECT && (endPos < 0 || startPos > lbufWidth))
1263                 || (flagREFLECT && (startPos < 0 || endPos > lbufWidth)))
1264                 return;
1265
1266         // Otherwise, find the clip limits and clip the phrase as well...
1267         // NOTE: I'm fudging here by letting the actual blit overstep the bounds of the
1268         //       line buffer, but it shouldn't matter since there are two unused line
1269         //       buffers below and nothing above and I'll at most write 40 bytes outside
1270         //       the line buffer... I could use a fractional clip begin/end value, but
1271         //       this makes the blit a *lot* more hairy. I might fix this in the future
1272         //       if it becomes necessary. (JLH)
1273         //       Probably wouldn't be *that* hairy. Just use a delta that tells the inner loop
1274         //       which pixel in the phrase is being written, and quit when either end of phrases
1275         //       is reached or line buffer extents are surpassed.
1276
1277 //This stuff is probably wrong as well... !!! FIX !!!
1278 //The strange thing is that it seems to work, but that's no guarantee that it's bulletproof!
1279 //Yup. Seems that JagMania doesn't work correctly with this...
1280 //Dunno if this is the problem, but Atari Karts is showing *some* of the road now...
1281 //Actually, it is! Or, it was. It doesn't seem to be clipping here, so the problem lies
1282 //elsewhere! Hmm. Putting the scaling code into the 1/2/8 BPP cases seems to draw the ground
1283 // a bit more accurately... Strange!
1284 //It's probably a case of the REFLECT flag being set and the background being written
1285 //from the right side of the screen...
1286 //But no, it isn't... At least if the diagnostics are telling the truth!
1287
1288         // NOTE: We're just using endPos to figure out how much, if any, to clip by.
1289         // ALSO: There may be another case where we start out of bounds and end out of bounds...!
1290         // !!! FIX !!!
1291
1292 //There's a problem here with scaledPhrasePixels in that it can be forced to zero when
1293 //the scaling factor is small. So fix it already! !!! FIX !!!
1294 /*if (scaledPhrasePixels == 0)
1295 {
1296         WriteLog("OP: [Scaled] We're about to encounter a divide by zero error!\n");
1297         DumpScaledObject(p0, p1, p2);
1298 }//*/
1299 //NOTE: I'm almost 100% sure that this is wrong... And it is! :-p
1300
1301 //Try a simple example...
1302 // Let's say we have a 8 BPP scanline with an hscale of $80 (4). Our xpos is -10,
1303 // non-flipped. Pixels in the bitmap are XYZXYZXYZXYZXYZ.
1304 // Scaled up, they would be XXXXYYYYZZZZXXXXYYYYZZZZXXXXYYYYZZZZ...
1305 //
1306 // Normally, we would expect this in the line buffer:
1307 // ZZXXXXYYYYZZZZXXXXYYYYZZZZ...
1308 //
1309 // But instead we're getting:
1310 // XXXXYYYYZZZZXXXXYYYYZZZZ...
1311 //
1312 // or are we??? It would seem so, simply by virtue of the fact that we're NOT starting
1313 // on negative boundary--or are we? Hmm...
1314 // cw = 10, dcw = pcw = 10 / ([8 * 4 = 32] 32) = 0, sp = -10
1315 //
1316 // Let's try a real world example:
1317 //
1318 //OP: Scaled bitmap (70, 8 BPP, spp=28) sp (-400) < 0... [new sp=-8, cw=400, dcw=pcw=14]
1319 //OP: Scaled bitmap (6F, 8 BPP, spp=27) sp (-395) < 0... [new sp=-17, cw=395, dcw=pcw=14]
1320 //
1321 // Really, spp is 27.75 in the second case...
1322 // So... If we do 395 / 27.75, we get 14. Ok so far... If we scale that against the
1323 // start position (14 * 27.75), we get -6.5... NOT -17!
1324
1325 //Now it seems we're working OK, at least for the first case...
1326 uint32 scaledPhrasePixelsUS = phraseWidthToPixels[depth] * hscale;
1327
1328         if (startPos < 0)                       // Case #1: Begin out, end in, L to R
1329 {
1330 extern int start_logging;
1331 if (start_logging)
1332         WriteLog("OP: Scaled bitmap (%02X, %u BPP, spp=%u) start pos (%i) < 0...", hscale, op_bitmap_bit_depth[depth], scaledPhrasePixels, startPos);
1333 //              clippedWidth = 0 - startPos,
1334                 clippedWidth = (0 - startPos) << 5,
1335 //              dataClippedWidth = phraseClippedWidth = clippedWidth / scaledPhrasePixels,
1336                 dataClippedWidth = phraseClippedWidth = (clippedWidth / scaledPhrasePixelsUS) >> 5,
1337 //              startPos = 0 - (clippedWidth % scaledPhrasePixels);
1338                 startPos += (dataClippedWidth * scaledPhrasePixelsUS) >> 5;
1339 if (start_logging)
1340         WriteLog(" [new sp=%i, cw=%i, dcw=pcw=%i]\n", startPos, clippedWidth, dataClippedWidth);
1341 }
1342
1343         if (endPos < 0)                         // Case #2: Begin in, end out, R to L
1344                 clippedWidth = 0 - endPos,
1345                 phraseClippedWidth = clippedWidth / scaledPhrasePixels;
1346
1347         if (endPos > lbufWidth)         // Case #3: Begin in, end out, L to R
1348                 clippedWidth = endPos - lbufWidth,
1349                 phraseClippedWidth = clippedWidth / scaledPhrasePixels;
1350
1351         if (startPos > lbufWidth)       // Case #4: Begin out, end in, R to L
1352                 clippedWidth = startPos - lbufWidth,
1353                 dataClippedWidth = phraseClippedWidth = clippedWidth / scaledPhrasePixels,
1354                 startPos = lbufWidth + (clippedWidth % scaledPhrasePixels);
1355
1356 extern int op_start_log;
1357 if (op_start_log && clippedWidth != 0)
1358         WriteLog("OP: Clipped line. SP=%i, EP=%i, clip=%u, iwidth=%u, hscale=%02X\n", startPos, endPos, clippedWidth, iwidth, hscale);
1359 if (op_start_log && startPos == 13)
1360 {
1361         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);
1362         DumpScaledObject(p0, p1, p2);
1363         if (iwidth == 7)
1364         {
1365                 WriteLog("    %08X: ", data);
1366                 for(int i=0; i<7*8; i++)
1367                         WriteLog("%02X ", JaguarReadByte(data+i));
1368                 WriteLog("\n");
1369         }
1370 }
1371         // If the image is sitting on the line buffer left or right edge, we need to compensate
1372         // by decreasing the image phrase width accordingly.
1373         iwidth -= phraseClippedWidth;
1374
1375         // Also, if we're clipping the phrase we need to make sure we're in the correct part of
1376         // the pixel data.
1377 //      data += phraseClippedWidth * (pitch << 3);
1378         data += dataClippedWidth * (pitch << 3);
1379
1380         // NOTE: When the bitmap is in REFLECT mode, the XPOS marks the *right* side of the
1381         //       bitmap! This makes clipping & etc. MUCH, much easier...!
1382 //      uint32 lbufAddress = 0x1800 + (!in24BPPMode ? leftMargin * 2 : leftMargin * 4);
1383 //      uint32 lbufAddress = 0x1800 + (!in24BPPMode ? startPos * 2 : startPos * 4);
1384         uint32 lbufAddress = 0x1800 + startPos * 2;
1385         uint8 * currentLineBuffer = &tomRam8[lbufAddress];
1386 //uint8 * lineBufferLowerLimit = &tom_ram_8[0x1800],
1387 //      * lineBufferUpperLimit = &tom_ram_8[0x1800 + 719];
1388
1389         // Render.
1390
1391 // Hmm. We check above for 24 BPP mode, but don't do anything about it below...
1392 // If we *were* in 24 BPP mode, how would you convert CRY to RGB24? Seems to me
1393 // that if you're in CRY mode then you wouldn't be able to use 24 BPP bitmaps
1394 // anyway.
1395 // This seems to be the case (at least according to the Midsummer docs)...!
1396
1397         if (depth == 0)                                                                 // 1 BPP
1398         {
1399 if (firstPix != 0)
1400         WriteLog("OP: Scaled bitmap @ 1 BPP requesting FIRSTPIX!\n");
1401                 // The LSB of flags is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1402                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1403
1404                 int pixCount = 0;
1405                 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1406
1407                 while ((int32)iwidth > 0)
1408                 {
1409                         uint8 bits = pixels >> 63;
1410
1411 #ifndef OP_USES_PALETTE_ZERO
1412                         if (flagTRANS && bits == 0)
1413 #else
1414                         if (flagTRANS && (paletteRAM16[index | bits] == 0))
1415 #endif
1416                                 ;       // Do nothing...
1417                         else
1418                         {
1419                                 if (!flagRMW)
1420                                         // This is the *only* correct use of endian-dependent code
1421                                         // (i.e., mem-to-mem direct copying)!
1422                                         *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1423                                 else
1424                                         *currentLineBuffer =
1425                                                 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1426                                         *(currentLineBuffer + 1) =
1427                                                 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1428                         }
1429
1430                         currentLineBuffer += lbufDelta;
1431
1432 /*
1433 The reason we subtract the horizontalRemainder *after* the test is because we had too few
1434 bytes for horizontalRemainder to properly recognize a negative number. But now it's 16 bits
1435 wide, so we could probably go back to that (as long as we make it an int16 and not a uint16!)
1436 */
1437 /*                      horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1438                         while (horizontalRemainder & 0x80)
1439                         {
1440                                 horizontalRemainder += hscale;
1441                                 pixCount++;
1442                                 pixels <<= 1;
1443                         }//*/
1444 //                      while (horizontalRemainder <= 0x20)             // I.e., it's <= 1.0 (*before* subtraction)
1445                         while (horizontalRemainder < 0x20)              // I.e., it's <= 1.0 (*before* subtraction)
1446                         {
1447                                 horizontalRemainder += hscale;
1448                                 pixCount++;
1449                                 pixels <<= 1;
1450                         }
1451                         horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1452
1453                         if (pixCount > 63)
1454                         {
1455                                 int phrasesToSkip = pixCount / 64, pixelShift = pixCount % 64;
1456
1457                                 data += (pitch << 3) * phrasesToSkip;
1458                                 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1459                                 pixels <<= 1 * pixelShift;
1460                                 iwidth -= phrasesToSkip;
1461                                 pixCount = pixelShift;
1462                         }
1463                 }
1464         }
1465         else if (depth == 1)                                                    // 2 BPP
1466         {
1467 if (firstPix != 0)
1468         WriteLog("OP: Scaled bitmap @ 2 BPP requesting FIRSTPIX!\n");
1469                 index &= 0xFC;                                                          // Top six bits form CLUT index
1470                 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1471                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1472
1473                 int pixCount = 0;
1474                 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1475
1476                 while ((int32)iwidth > 0)
1477                 {
1478                         uint8 bits = pixels >> 62;
1479
1480 #ifndef OP_USES_PALETTE_ZERO
1481                         if (flagTRANS && bits == 0)
1482 #else
1483                         if (flagTRANS && (paletteRAM16[index | bits] == 0))
1484 #endif
1485                                 ;       // Do nothing...
1486                         else
1487                         {
1488                                 if (!flagRMW)
1489                                         // This is the *only* correct use of endian-dependent code
1490                                         // (i.e., mem-to-mem direct copying)!
1491                                         *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1492                                 else
1493                                         *currentLineBuffer =
1494                                                 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1495                                         *(currentLineBuffer + 1) =
1496                                                 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1497                         }
1498
1499                         currentLineBuffer += lbufDelta;
1500
1501 /*                      horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1502                         while (horizontalRemainder & 0x80)
1503                         {
1504                                 horizontalRemainder += hscale;
1505                                 pixCount++;
1506                                 pixels <<= 2;
1507                         }//*/
1508 //                      while (horizontalRemainder <= 0x20)             // I.e., it's <= 0 (*before* subtraction)
1509                         while (horizontalRemainder < 0x20)              // I.e., it's <= 1.0 (*before* subtraction)
1510                         {
1511                                 horizontalRemainder += hscale;
1512                                 pixCount++;
1513                                 pixels <<= 2;
1514                         }
1515                         horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1516
1517                         if (pixCount > 31)
1518                         {
1519                                 int phrasesToSkip = pixCount / 32, pixelShift = pixCount % 32;
1520
1521                                 data += (pitch << 3) * phrasesToSkip;
1522                                 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1523                                 pixels <<= 2 * pixelShift;
1524                                 iwidth -= phrasesToSkip;
1525                                 pixCount = pixelShift;
1526                         }
1527                 }
1528         }
1529         else if (depth == 2)                                                    // 4 BPP
1530         {
1531 if (firstPix != 0)
1532         WriteLog("OP: Scaled bitmap @ 4 BPP requesting FIRSTPIX!\n");
1533                 index &= 0xF0;                                                          // Top four bits form CLUT index
1534                 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1535                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1536
1537                 int pixCount = 0;
1538                 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1539
1540                 while ((int32)iwidth > 0)
1541                 {
1542                         uint8 bits = pixels >> 60;
1543
1544 #ifndef OP_USES_PALETTE_ZERO
1545                         if (flagTRANS && bits == 0)
1546 #else
1547                         if (flagTRANS && (paletteRAM16[index | bits] == 0))
1548 #endif
1549                                 ;       // Do nothing...
1550                         else
1551                         {
1552                                 if (!flagRMW)
1553                                         // This is the *only* correct use of endian-dependent code
1554                                         // (i.e., mem-to-mem direct copying)!
1555                                         *(uint16 *)currentLineBuffer = paletteRAM16[index | bits];
1556                                 else
1557                                         *currentLineBuffer =
1558                                                 BLEND_CR(*currentLineBuffer, paletteRAM[(index | bits) << 1]),
1559                                         *(currentLineBuffer + 1) =
1560                                                 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[((index | bits) << 1) + 1]);
1561                         }
1562
1563                         currentLineBuffer += lbufDelta;
1564
1565 /*                      horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1566                         while (horizontalRemainder & 0x80)
1567                         {
1568                                 horizontalRemainder += hscale;
1569                                 pixCount++;
1570                                 pixels <<= 4;
1571                         }//*/
1572 //                      while (horizontalRemainder <= 0x20)             // I.e., it's <= 0 (*before* subtraction)
1573                         while (horizontalRemainder < 0x20)              // I.e., it's <= 0 (*before* subtraction)
1574                         {
1575                                 horizontalRemainder += hscale;
1576                                 pixCount++;
1577                                 pixels <<= 4;
1578                         }
1579                         horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1580
1581                         if (pixCount > 15)
1582                         {
1583                                 int phrasesToSkip = pixCount / 16, pixelShift = pixCount % 16;
1584
1585                                 data += (pitch << 3) * phrasesToSkip;
1586                                 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1587                                 pixels <<= 4 * pixelShift;
1588                                 iwidth -= phrasesToSkip;
1589                                 pixCount = pixelShift;
1590                         }
1591                 }
1592         }
1593         else if (depth == 3)                                                    // 8 BPP
1594         {
1595 if (firstPix)
1596         WriteLog("OP: Scaled bitmap @ 8 BPP requesting FIRSTPIX! (fp=%u)\n", firstPix);
1597                 // The LSB is OPFLAG_REFLECT, so sign extend it and or 2 into it.
1598                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1599
1600                 int pixCount = 0;
1601                 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1602
1603                 while ((int32)iwidth > 0)
1604                 {
1605                         uint8 bits = pixels >> 56;
1606
1607 #ifndef OP_USES_PALETTE_ZERO
1608                         if (flagTRANS && bits == 0)
1609 #else
1610                         if (flagTRANS && (paletteRAM16[bits] == 0))
1611 #endif
1612                                 ;       // Do nothing...
1613                         else
1614                         {
1615                                 if (!flagRMW)
1616                                         // This is the *only* correct use of endian-dependent code
1617                                         // (i.e., mem-to-mem direct copying)!
1618                                         *(uint16 *)currentLineBuffer = paletteRAM16[bits];
1619 /*                              {
1620                                         if (currentLineBuffer >= lineBufferLowerLimit && currentLineBuffer <= lineBufferUpperLimit)
1621                                                 *(uint16 *)currentLineBuffer = paletteRAM16[bits];
1622                                 }*/
1623                                 else
1624                                         *currentLineBuffer =
1625                                                 BLEND_CR(*currentLineBuffer, paletteRAM[bits << 1]),
1626                                         *(currentLineBuffer + 1) =
1627                                                 BLEND_Y(*(currentLineBuffer + 1), paletteRAM[(bits << 1) + 1]);
1628                         }
1629
1630                         currentLineBuffer += lbufDelta;
1631
1632 //                      while (horizontalRemainder <= 0x20)             // I.e., it's <= 0 (*before* subtraction)
1633                         while (horizontalRemainder < 0x20)              // I.e., it's <= 1.0 (*before* subtraction)
1634                         {
1635                                 horizontalRemainder += hscale;
1636                                 pixCount++;
1637                                 pixels <<= 8;
1638                         }
1639                         horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1640
1641                         if (pixCount > 7)
1642                         {
1643                                 int phrasesToSkip = pixCount / 8, pixelShift = pixCount % 8;
1644
1645                                 data += (pitch << 3) * phrasesToSkip;
1646                                 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1647                                 pixels <<= 8 * pixelShift;
1648                                 iwidth -= phrasesToSkip;
1649                                 pixCount = pixelShift;
1650                         }
1651                 }
1652         }
1653         else if (depth == 4)                                                    // 16 BPP
1654         {
1655 if (firstPix != 0)
1656         WriteLog("OP: Scaled bitmap @ 16 BPP requesting FIRSTPIX!\n");
1657                 // The LSB is OPFLAG_REFLECT, so sign extend it and OR 2 into it.
1658                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 5) | 0x02;
1659
1660                 int pixCount = 0;
1661                 uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1662
1663                 while ((int32)iwidth > 0)
1664                 {
1665                         uint8 bitsHi = pixels >> 56, bitsLo = pixels >> 48;
1666
1667 //This doesn't seem right... Let's try the encoded black value ($8800):
1668 //Apparently, CRY 0 maps to $8800...
1669                                 if (flagTRANS && ((bitsLo | bitsHi) == 0))
1670 //                              if (flagTRANS && (bitsHi == 0x88) && (bitsLo == 0x00))
1671                                 ;       // Do nothing...
1672                         else
1673                         {
1674                                 if (!flagRMW)
1675                                         *currentLineBuffer = bitsHi,
1676                                         *(currentLineBuffer + 1) = bitsLo;
1677                                 else
1678                                         *currentLineBuffer =
1679                                                 BLEND_CR(*currentLineBuffer, bitsHi),
1680                                         *(currentLineBuffer + 1) =
1681                                                 BLEND_Y(*(currentLineBuffer + 1), bitsLo);
1682                         }
1683
1684                         currentLineBuffer += lbufDelta;
1685
1686 /*                      horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1687                         while (horizontalRemainder & 0x80)
1688                         {
1689                                 horizontalRemainder += hscale;
1690                                 pixCount++;
1691                                 pixels <<= 16;
1692                         }//*/
1693 //                      while (horizontalRemainder <= 0x20)             // I.e., it's <= 0 (*before* subtraction)
1694                         while (horizontalRemainder < 0x20)              // I.e., it's <= 1.0 (*before* subtraction)
1695                         {
1696                                 horizontalRemainder += hscale;
1697                                 pixCount++;
1698                                 pixels <<= 16;
1699                         }
1700                         horizontalRemainder -= 0x20;            // Subtract 1.0f in [3.5] fixed point format
1701 //*/
1702                         if (pixCount > 3)
1703                         {
1704                                 int phrasesToSkip = pixCount / 4, pixelShift = pixCount % 4;
1705
1706                                 data += (pitch << 3) * phrasesToSkip;
1707                                 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1708                                 pixels <<= 16 * pixelShift;
1709
1710                                 iwidth -= phrasesToSkip;
1711
1712                                 pixCount = pixelShift;
1713                         }
1714                 }
1715         }
1716         else if (depth == 5)                                                    // 24 BPP
1717         {
1718 //I'm not sure that you can scale a 24 BPP bitmap properly--the JTRM seem to indicate as much.
1719 WriteLog("OP: Writing 24 BPP scaled bitmap!\n");
1720 if (firstPix != 0)
1721         WriteLog("OP: Scaled bitmap @ 24 BPP requesting FIRSTPIX!\n");
1722                 // Not sure, but I think RMW only works with 16 BPP and below, and only in CRY mode...
1723                 // The LSB is OPFLAG_REFLECT, so sign extend it and or 4 into it.
1724                 int32 lbufDelta = ((int8)((flags << 7) & 0xFF) >> 4) | 0x04;
1725
1726                 while (iwidth--)
1727                 {
1728                         // Fetch phrase...
1729                         uint64 pixels = ((uint64)JaguarReadLong(data, OP) << 32) | JaguarReadLong(data + 4, OP);
1730                         data += pitch << 3;                                             // Multiply pitch * 8 (optimize: precompute this value)
1731
1732                         for(int i=0; i<2; i++)
1733                         {
1734                                 uint8 bits3 = pixels >> 56, bits2 = pixels >> 48,
1735                                         bits1 = pixels >> 40, bits0 = pixels >> 32;
1736
1737                                 if (flagTRANS && (bits3 | bits2 | bits1 | bits0) == 0)
1738                                         ;       // Do nothing...
1739                                 else
1740                                         *currentLineBuffer = bits3,
1741                                         *(currentLineBuffer + 1) = bits2,
1742                                         *(currentLineBuffer + 2) = bits1,
1743                                         *(currentLineBuffer + 3) = bits0;
1744
1745                                 currentLineBuffer += lbufDelta;
1746                                 pixels <<= 32;
1747                         }
1748                 }
1749         }
1750 }