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