Ticket #8109: dig-corruption.diff

File dig-corruption.diff, 7.7 KB (added by eriktorbjorn, 17 years ago)

Patch against an October 25 CVS snapshot

  • scummvm/scumm/akos.h

    diff -ur ScummVM-cvs20021025/scummvm/scumm/akos.h ScummVM-cvs20021025+hack/scummvm/scumm/akos.h
    old new  
    127127        AkosRenderer(Scumm *scumm) {
    128128                memset(this, 0, sizeof(AkosRenderer));
    129129                _vm = scumm;
    130                 _numStrips = _vm->gdi._numStrips;
     130                _numStrips = MAX_NUM_STRIPS;
    131131        }
    132132        bool drawCostume();
    133133        void setPalette(byte *palette);
  • scummvm/scumm/costume.h

    diff -ur ScummVM-cvs20021025/scummvm/scumm/costume.h ScummVM-cvs20021025+hack/scummvm/scumm/costume.h
    old new  
    108108        void setCostume(int costume);
    109109
    110110public:
    111         CostumeRenderer(Scumm *vm) : _vm(vm), _numStrips(vm->gdi._numStrips), _loaded(vm) {}
     111        CostumeRenderer(Scumm *vm) : _vm(vm), _numStrips(MAX_NUM_STRIPS), _loaded(vm) {}
    112112};
    113113
    114114#endif
  • scummvm/scumm/gfx.cpp

    diff -ur ScummVM-cvs20021025/scummvm/scumm/gfx.cpp ScummVM-cvs20021025+hack/scummvm/scumm/gfx.cpp
    old new  
    415415        assert(gdi._numZBuffer >= 1 && gdi._numZBuffer <= 5);
    416416
    417417        if (_features & GF_AFTER_V7)
    418                 itemsize = (virtscr[0].height + 4) * gdi._numStrips;
     418                itemsize = (virtscr[0].height + 4) * MAX_NUM_STRIPS;
    419419        else
    420                 itemsize = (_scrHeight + 4) * gdi._numStrips;
     420                itemsize = (_scrHeight + 4) * MAX_NUM_STRIPS;
    421421
    422422
    423423        size = itemsize * gdi._numZBuffer;
     
    910910                else
    911911                        _bgbak_ptr = _backbuff_ptr;
    912912
    913                 _mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + (y * _numStrips + x);
     913                _mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + (y * MAX_NUM_STRIPS + x);
    914914
    915915                where_draw_ptr = _bgbak_ptr;
    916916                decompressBitmap();
     
    952952                if (flag & dbDrawMaskOnAll) {
    953953                        _z_plane_ptr = zplane_list[1] + READ_LE_UINT16(zplane_list[1] + stripnr * 2 + 8);
    954954                        for (i = 0; i < numzbuf; i++) {
    955                                 _mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * _numStrips + x + _imgBufOffs[i];
     955                                _mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * MAX_NUM_STRIPS + x + _imgBufOffs[i];
    956956                                if (_useOrDecompress && flag & dbAllowMaskOr)
    957957                                        decompressMaskImgOr();
    958958                                else
     
    973973                                } else
    974974                                        offs = READ_LE_UINT16(zplane_list[i] + stripnr * 2 + 8);
    975975
    976                                 _mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * _numStrips + x + _imgBufOffs[i];
     976                                _mask_ptr_dest = _vm->getResourceAddress(rtBuffer, 9) + y * MAX_NUM_STRIPS + x + _imgBufOffs[i];
    977977
    978978                                if (offs) {
    979979                                        _z_plane_ptr = zplane_list[i] + offs;
     
    985985                                } else {
    986986                                        if (!(_useOrDecompress && flag & dbAllowMaskOr))
    987987                                                for (int height = 0; height < _numLinesToProcess; height++)
    988                                                         _mask_ptr_dest[height * _numStrips] = 0;
     988                                                        _mask_ptr_dest[height * MAX_NUM_STRIPS] = 0;
    989989                                        /* needs better abstraction, FIXME */
    990990                                }
    991991                        }
     
    11661166                }
    11671167                src += _vm->_realWidth;
    11681168                dst += _vm->_realWidth;
    1169                 mask += _numStrips;
     1169                mask += MAX_NUM_STRIPS;
    11701170        } while (--height);
    11711171}
    11721172
     
    12011201                        ((uint32 *)dst)[1] = 0;
    12021202                }
    12031203                dst += _vm->_realWidth;
    1204                 mask += _numStrips;
     1204                mask += MAX_NUM_STRIPS;
    12051205        } while (--height);
    12061206}
    12071207
     
    12241224        int height = _numLinesToProcess;
    12251225        byte b, c;
    12261226       
    1227         height--;               // FIXME: This seems to fix The Dig nexus wrapping corrupting memory..
    1228                                 //        and doesn't break any other games.. but is it correct? If so,
    1229                                 //        do we need to mirror this change anywhere else?
    12301227        while (1) {
    12311228                b = *src++;
    12321229
     
    12361233
    12371234                        do {
    12381235                                *dst = c;
    1239                                 dst += _numStrips;
     1236                                dst += MAX_NUM_STRIPS;
    12401237                                if (!--height)
    12411238                                        return;
    12421239                        } while (--b);
    12431240                } else {
    12441241                        do {
    12451242                                *dst = *src++;
    1246                                 dst += _numStrips;
     1243                                dst += MAX_NUM_STRIPS;
    12471244                                if (!--height)
    12481245                                        return;
    12491246                        } while (--b);
     
    12661263
    12671264                        do {
    12681265                                *dst |= c;
    1269                                 dst += _numStrips;
     1266                                dst += MAX_NUM_STRIPS;
    12701267                                if (!--height)
    12711268                                        return;
    12721269                        } while (--b);
    12731270                } else {
    12741271                        do {
    12751272                                *dst |= *src++;
    1276                                 dst += _numStrips;
     1273                                dst += MAX_NUM_STRIPS;
    12771274                                if (!--height)
    12781275                                        return;
    12791276                        } while (--b);
     
    17981795
    17991796        backbuff = vs->screenPtr + height;
    18001797        bgbak = getResourceAddress(rtBuffer, vs->number + 5) + height;
    1801         mask = getResourceAddress(rtBuffer, 9) + top * gdi._numStrips + (left >> 3) + _screenStartStrip;
     1798        mask = getResourceAddress(rtBuffer, 9) + top * MAX_NUM_STRIPS + (left >> 3) + _screenStartStrip;
    18021799        if (vs->number == 0) {
    18031800                mask += vs->topline * 216;
    18041801        }
     
    18121809                if (vs->number == 0 && charset._hasMask && height) {
    18131810                        do {
    18141811                                memset(mask, 0, widthmod);
    1815                                 mask += gdi._numStrips;
     1812                                mask += MAX_NUM_STRIPS;
    18161813                        } while (--height);
    18171814                }
    18181815        } else {
     
    26922689                vs->bdirty[strip] = bottom;
    26932690
    26942691        offs = (top * _numStrips + _vm->_screenStartStrip + strip);
    2695         _mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + offs;
     2692        _mask_ptr = _vm->getResourceAddress(rtBuffer, 9) + top * MAX_NUM_STRIPS + _vm->_screenStartStrip + strip;
    26962693        _bgbak_ptr = _vm->getResourceAddress(rtBuffer, 5) + (offs << 3);
    26972694        _backbuff_ptr = vs->screenPtr + (offs << 3);
    26982695
     
    27342731                t = 0;
    27352732
    27362733        r >>= 3;
    2737         if (r > gdi._numStrips - 1)
    2738                 r = gdi._numStrips - 1;
     2734        if (r > MAX_NUM_STRIPS - 1)
     2735                r = MAX_NUM_STRIPS - 1;
    27392736
    2740         mem += l + t * gdi._numStrips;
     2737        mem += l + t * MAX_NUM_STRIPS;
    27412738
    27422739        w = r - l;
    27432740        h = b - t + 1;
     
    27472744                        if (mem[i]) {
    27482745                                return true;
    27492746                        }
    2750                 mem += gdi._numStrips;
     2747                mem += MAX_NUM_STRIPS;
    27512748        } while (--h);
    27522749
    27532750        return false;
     
    32463243                                for (i = 0; i < num; i++) {
    32473244                                        if (bd->scale_x == 255 || scale_cols[src_x]) {
    32483245                                                if (dst_x >= 0 && dst_x < bd->outwidth) {
    3249                                                         if (!(*(mask + dst_y * 40 + (dst_x >> 3)) & revBitMask[dst_x & 7]))
     3246                                                        if (!(*(mask + dst_y * MAX_NUM_STRIPS + (dst_x >> 3)) & revBitMask[dst_x & 7]))
    32503247                                                       
    32513248                                                                *d = blend(_currentPalette, color, *d);
    32523249                                                }
     
    32593256                                for (i = 0; i < num; i++) {
    32603257                                        if (bd->scale_x == 255 || scale_cols[src_x]) {
    32613258                                                if (dst_x >= 0 && dst_x < bd->outwidth)
    3262                                                         if (!(*(mask + dst_y * 40 + (dst_x >> 3)) & revBitMask[dst_x & 7]))
     3259                                                        if (!(*(mask + dst_y * MAX_NUM_STRIPS + (dst_x >> 3)) & revBitMask[dst_x & 7]))
    32633260                                                                *d = blend(_currentPalette, src[i], *d);
    32643261                                                d++;
    32653262                                                dst_x++;
  • scummvm/scumm/scumm.h

    diff -ur ScummVM-cvs20021025/scummvm/scumm/scumm.h ScummVM-cvs20021025+hack/scummvm/scumm/scumm.h
    old new  
    5252        NUM_LOCALSCRIPT = 60,
    5353        NUM_SHADOW_PALETTE = 8,
    5454        MAX_ACTORS = 30,
    55         KEY_SET_OPTIONS = 3456 // WinCE
     55        KEY_SET_OPTIONS = 3456, // WinCE
     56        MAX_NUM_STRIPS = 240
    5657};
    5758
    5859enum {
     
    869870        uint16 _palManipCounter;
    870871        byte *_palManipPalette;
    871872        byte *_palManipIntermediatePal;
    872         uint32 gfxUsageBits[240];
     873        uint32 gfxUsageBits[MAX_NUM_STRIPS];
    873874        byte *_shadowPalette;
    874875        int _shadowPaletteSize;
    875876        byte _currentPalette[0x300];
  • scummvm/scumm/string.cpp

    diff -ur ScummVM-cvs20021025/scummvm/scumm/string.cpp ScummVM-cvs20021025+hack/scummvm/scumm/string.cpp
    old new  
    10381038        }
    10391039
    10401040        _mask_ptr = _vm->getResourceAddress(rtBuffer, 9)
    1041                 + _drawTop * 40 + _left / 8 + _vm->_screenStartStrip;
     1041                + _drawTop * MAX_NUM_STRIPS + _left / 8 + _vm->_screenStartStrip;
    10421042
    10431043        _virtScreenHeight = vs->height;
    10441044        _charPtr += 4;
     
    11001100                        }
    11011101                }
    11021102                dst = (_dest_ptr += _vm->_realWidth);
    1103                 mask += 40;
     1103                mask += MAX_NUM_STRIPS;
    11041104                y++;
    11051105        }
    11061106}