Ticket #8109: dig-corruption3.diff

scummvm/scumm/akos.h

@@ -127 +127 @@
         AkosRenderer(Scumm *scumm) {
                 memset(this, 0, sizeof(AkosRenderer));
                 _vm = scumm;
-                _numStrips = _vm->gdi._numStrips;
+                _numStrips = _vm->_scrWidth / 8;
         }
         bool drawCostume();
         void setPalette(byte *palette);

scummvm/scumm/costume.h

@@ -108 +108 @@
         void setCostume(int costume);
 
 public:
-        CostumeRenderer(Scumm *vm) : _vm(vm), _numStrips(vm->gdi._numStrips), _loaded(vm) {}
+        CostumeRenderer(Scumm *vm) : _vm(vm), _numStrips(vm->_scrWidth / 8), _loaded(vm) {}
 };
 
 #endif

scummvm/scumm/gfx.cpp

@@ -378 +378 @@
 {
         byte *ptr;
         int size, itemsize, i;
+        int mask_pitch = _scrWidth / 8;
         byte *room;
 
         if (_features & GF_AFTER_V7) {
@@ -422 +423 @@
         assert(gdi._numZBuffer >= 1 && gdi._numZBuffer <= 5);
 
         if (_features & GF_AFTER_V7)
-                itemsize = (virtscr[0].height + 4) * gdi._numStrips;
+                itemsize = (virtscr[0].height + 4) * mask_pitch;
         else
-                itemsize = (_scrHeight + 4) * gdi._numStrips;
-
+                itemsize = (_scrHeight + 4) * mask_pitch;
 
         size = itemsize * gdi._numZBuffer;
+        debug(1, "Allocating %dx%d strips for mask buffer (%d bytes)", gdi._numZBuffer, _scrWidth / 8, size);
+
         createResource(rtBuffer, 9, size);
 
         for (i = 0; i < 4; i++)
@@ -840 +842 @@
         int sx;
         bool lightsOn;
 
+        int mask_pitch = _vm->_scrWidth / 8;
+
         // Check whether lights are turned on or not
         lightsOn = (_vm->_features & GF_AFTER_V6) || (vs->number != 0) || (_vm->_vars[_vm->VAR_CURRENT_LIGHTS] & LIGHTMODE_screen);
 
@@ -920 +924 @@
                 else
                         _bgbak_ptr = _backbuff_ptr;
 
-                _mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + (y * _numStrips + x);
+                _mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + (y * mask_pitch + x);
 
                 where_draw_ptr = _bgbak_ptr;
                 decompressBitmap();
@@ -962 +966 @@
                 if (flag & dbDrawMaskOnAll) {
                         _z_plane_ptr = zplane_list[1] + READ_LE_UINT16(zplane_list[1] + stripnr * 2 + 8);
                         for (i = 0; i < numzbuf; i++) {
-                                _mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * _numStrips + x + _imgBufOffs[i];
+                                _mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * mask_pitch + x + _imgBufOffs[i];
                                 if (_useOrDecompress && flag & dbAllowMaskOr)
                                         decompressMaskImgOr();
                                 else
@@ -983 +987 @@
                                 } else
                                         offs = READ_LE_UINT16(zplane_list[i] + stripnr * 2 + 8);
 
-                                _mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * _numStrips + x + _imgBufOffs[i];
+                                _mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * mask_pitch + x + _imgBufOffs[i];
 
                                 if (offs) {
                                         _z_plane_ptr = zplane_list[i] + offs;
@@ -995 +999 @@
                                 } else {
                                         if (!(_useOrDecompress && flag & dbAllowMaskOr))
                                                 for (int height = 0; height < _numLinesToProcess; height++)
-                                                        _mask_ptr_dest[height * _numStrips] = 0;
+                                                        _mask_ptr_dest[height * mask_pitch] = 0;
                                         /* needs better abstraction, FIXME */
                                 }
                         }
@@ -1148 +1152 @@
 void Gdi::draw8ColWithMasking()
 {
         int height = _numLinesToProcess;
+        int mask_pitch = _vm->_scrWidth / 8;
         byte *mask = _mask_ptr;
         byte *dst = _backbuff_ptr;
         byte *src = _bgbak_ptr;
@@ -1178 +1183 @@
                 }
                 src += _vm->_realWidth;
                 dst += _vm->_realWidth;
-                mask += _numStrips;
+                mask += mask_pitch;
         } while (--height);
 }
 
 void Gdi::clear8ColWithMasking()
 {
         int height = _numLinesToProcess;
+        int mask_pitch = _vm->_scrWidth / 8;
         byte *mask = _mask_ptr;
         byte *dst = _backbuff_ptr;
         byte maskbits;
@@ -1213 +1219 @@
                         ((uint32 *)dst)[1] = 0;
                 }
                 dst += _vm->_realWidth;
-                mask += _numStrips;
+                mask += mask_pitch;
         } while (--height);
 }
 
@@ -1234 +1240 @@
         byte *src = _z_plane_ptr;
         byte *dst = _mask_ptr_dest;
         int height = _numLinesToProcess;
+        int mask_pitch = _vm->_scrWidth / 8;
         byte b, c;
         
-        if ((_vm->_gameId == GID_DIG) && (_vm->_currentRoom == 23))
-                height--;
-                                // FIXME: This seems to fix The Dig nexus wrapping corrupting memory..
-                                //        and doesn't break any other games.. but is it correct? If so,
-                                //        do we need to mirror this change anywhere else?
         while (1) {
                 b = *src++;
 
@@ -1250 +1252 @@
 
                         do {
                                 *dst = c;
-                                dst += _numStrips;
+                                dst += mask_pitch;
                                 if (!--height)
                                         return;
                         } while (--b);
                 } else {
                         do {
                                 *dst = *src++;
-                                dst += _numStrips;
+                                dst += mask_pitch;
                                 if (!--height)
                                         return;
                         } while (--b);
@@ -1270 +1272 @@
         byte *src = _z_plane_ptr;
         byte *dst = _mask_ptr_dest;
         int height = _numLinesToProcess;
+        int mask_pitch = _vm->_scrWidth / 8;
         byte b, c;
 
         while (1) {
@@ -1280 +1283 @@
 
                         do {
                                 *dst |= c;
-                                dst += _numStrips;
+                                dst += mask_pitch;
                                 if (!--height)
                                         return;
                         } while (--b);
                 } else {
                         do {
                                 *dst |= *src++;
-                                dst += _numStrips;
+                                dst += mask_pitch;
                                 if (!--height)
                                         return;
                         } while (--b);
@@ -1776 +1779 @@
 void Scumm::restoreBG(int left, int top, int right, int bottom)
 {
         VirtScreen *vs;
-        int topline, height, width, widthmod;
-        byte *backbuff, *bgbak, *mask;
+        int topline, height, width;
+        byte *backbuff, *bgbak;
 
         if (left == right || top == bottom)
                 return;
@@ -1812 +1815 @@
 
         backbuff = vs->screenPtr + height;
         bgbak = getResourceAddress(rtBuffer, vs->number + 5) + height;
-        mask = getResourceAddress(rtBuffer, 9) + top * gdi._numStrips + (left >> 3) + _screenStartStrip;
-        if (vs->number == 0) {
-                // FIXME: hardcoded value
-                mask += vs->topline * 216;
-        }
 
         height = bottom - top;
         width = right - left;
-        widthmod = (width >> 2) + 2;
 
         if (vs->alloctwobuffers && _currentRoom != 0 /*&& _vars[VAR_V5_DRAWFLAGS]&2 */ ) {
                 blit(backbuff, bgbak, width, height);
                 if (vs->number == 0 && charset._hasMask && height) {
+                        byte *mask;
+                        int mask_pitch = _scrWidth / 8;
+                        int mask_width = (width >> 3);
+
+                        if (width & 0x07)
+                                mask_width++;
+
+                        mask = getResourceAddress(rtBuffer, 9) + top * mask_pitch + (left >> 3) + _screenStartStrip;
+                        if (vs->number == 0)
+                                mask += vs->topline * mask_pitch;
+
                         do {
-                                memset(mask, 0, widthmod);
-                                mask += gdi._numStrips;
+                                memset(mask, 0, mask_width);
+                                mask += mask_pitch;
                         } while (--height);
                 }
         } else {
@@ -2698 +2706 @@
 void Gdi::resetBackground(int top, int bottom, int strip)
 {
         VirtScreen *vs = &_vm->virtscr[0];
+        int mask_pitch = _vm->_scrWidth / 8;
         int offs;
 
         if (top < vs->tdirty[strip])
@@ -2707 +2716 @@
                 vs->bdirty[strip] = bottom;
 
         offs = (top * _numStrips + _vm->_screenStartStrip + strip);
-        _mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + offs;
+        _mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + top * mask_pitch + _vm->_screenStartStrip + strip;
         _bgbak_ptr = _vm->getResourceAddress(rtBuffer, 5) + (offs << 3);
         _backbuff_ptr = vs->screenPtr + (offs << 3);
 
@@ -2740 +2749 @@
 
 byte Scumm::isMaskActiveAt(int l, int t, int r, int b, byte *mem)
 {
+        int mask_pitch = _scrWidth / 8;
         int w, h, i;
 
         l >>= 3;
@@ -2749 +2759 @@
                 t = 0;
 
         r >>= 3;
-        if (r > gdi._numStrips - 1)
-                r = gdi._numStrips - 1;
+        if (r > mask_pitch - 1)
+                r = mask_pitch - 1;
 
-        mem += l + t * gdi._numStrips;
+        mem += l + t * mask_pitch;
 
         w = r - l;
         h = b - t + 1;
@@ -2762 +2772 @@
                         if (mem[i]) {
                                 return true;
                         }
-                mem += gdi._numStrips;
+                mem += mask_pitch;
         } while (--h);
 
         return false;
@@ -3175 +3185 @@
 
 void Scumm::drawBomp(BompDrawData *bd, int param1, byte *dataPtr, int param2, int param3)
 {
+        int mask_pitch = _scrWidth / 8;
         byte *scale_rows = NULL;
         byte *scale_cols = NULL;
         byte *dest = bd->out + bd->y * bd->outwidth, *src;
@@ -3261 +3272 @@
                                 for (i = 0; i < num; i++) {
                                         if (bd->scale_x == 255 || scale_cols[src_x]) {
                                                 if (dst_x >= 0 && dst_x < bd->outwidth) {
-                                                        if (!(*(mask + dst_y * gdi._numStrips + (dst_x >> 3)) & revBitMask[dst_x & 7]))
+                                                        if (!(*(mask + dst_y * mask_pitch + (dst_x >> 3)) & revBitMask[dst_x & 7]))
                                                         
                                                                 *d = blend(_currentPalette, color, *d);
                                                 }
@@ -3274 +3285 @@
                                 for (i = 0; i < num; i++) {
                                         if (bd->scale_x == 255 || scale_cols[src_x]) {
                                                 if (dst_x >= 0 && dst_x < bd->outwidth)
-                                                        if (!(*(mask + dst_y * gdi._numStrips + (dst_x >> 3)) & revBitMask[dst_x & 7]))
+                                                        if (!(*(mask + dst_y * mask_pitch + (dst_x >> 3)) & revBitMask[dst_x & 7]))
                                                                 *d = blend(_currentPalette, src[i], *d);
                                                 d++;
                                                 dst_x++;

scummvm/scumm/string.cpp

@@ -941 +941 @@
 
 void CharsetRenderer::printChar(int chr)
 {
+        int mask_pitch = _vm->_scrWidth / 8;
         int d, right;
         VirtScreen *vs;
 
@@ -1040 +1041 @@
         }
 
         _mask_ptr = _vm->getResourceAddress(rtBuffer, 9)
-                + _drawTop * _vm->gdi._numStrips + _left / 8 + _vm->_screenStartStrip;
+                + _drawTop * mask_pitch + _left / 8 + _vm->_screenStartStrip;
 
         _virtScreenHeight = vs->height;
         _charPtr += 4;
@@ -1062 +1063 @@
 
 void CharsetRenderer::drawBits()
 {
+        int mask_pitch = _vm->_scrWidth / 8;
         bool usemask;
         byte *dst, *mask, maskmask;
         int y, x;
@@ -1102 +1104 @@
                         }
                 }
                 dst = (_dest_ptr += _vm->_realWidth);
-                mask += 40;
+                mask += mask_pitch;
                 y++;
         }
 }