Ticket #8247: be-unaligned-full.diff

File be-unaligned-full.diff, 29.4 KB (added by eriktorbjorn, 21 years ago)

Patch against a June 14 CVS snapshot

  • scummvm/common/scummsys.h 

    diff -ur ScummVM+orig/scummvm/common/scummsys.h ScummVM+hack/scummvm/common/scummsys.h
    old new  
    347347                return (b[0] << 24) + (b[1] << 16) + (b[2] << 8) + (b[3]);
    348348        }
    349349
    350         #define READ_BE_UINT32_UNALIGNED READ_BE_UINT32
    351         #define READ_BE_UINT16_UNALIGNED READ_BE_UINT16
     350        #define READ_UINT32(a) READ_LE_UINT32(a)
    352351
    353         #define READ_UINT32_UNALIGNED(a) READ_LE_UINT32(a)
     352        #define FROM_LE_32(a) (a)
     353        #define FROM_LE_16(a) (a)
    354354
    355         #define FROM_LE_32(__a__) __a__
    356         #define FROM_LE_16(__a__) __a__
    357 
    358         #define TO_LE_32(__a__) __a__
    359         #define TO_LE_16(__a__) __a__
     355        #define TO_LE_32(a) (a)
     356        #define TO_LE_16(a) (a)
    360357
    361358        #define TO_BE_32(a) SWAP_BYTES(a)
    362359
    … …  
    368365        #define MKID_BE(a) (a)
    369366        //#define MKID_BE(a) SWAP_BYTES(a)
    370367
    371         FORCEINLINE uint32 FROM_LE_32(uint32 a) {
    372                 return ((a >> 24) & 0xFF) + ((a >> 8) & 0xFF00) + (( a<< 8) & 0xFF0000) \
    373                                                 + ((a<<24)&0xFF000000);
    374         }
    375 
    376         FORCEINLINE uint16 FROM_LE_16(uint16 a) {
    377                 return ((a >> 8) & 0xFF) + ((a << 8) & 0xFF00);
     368        FORCEINLINE uint READ_LE_UINT16(const void *ptr) {
     369                const byte *b = (const byte *)ptr;
     370                return (b[1] << 8) + b[0];
    378371        }
    379372
    380         #define TO_LE_32 FROM_LE_32
    381         #define TO_LE_16 FROM_LE_16
     373        #if defined(SCUMM_NEED_ALIGNMENT)
     374                FORCEINLINE uint READ_BE_UINT16(const void *ptr) {
     375                        return (((const byte *)ptr)[0] << 8)|((const byte *)ptr)[1];
     376                }
     377        #else
     378                FORCEINLINE uint READ_BE_UINT16(const void *ptr) {
     379                        return *(const uint16 *)(ptr);
     380                }
     381        #endif
    382382
    383383        FORCEINLINE uint32 READ_LE_UINT32(const void *ptr) {
    384384                const byte *b = (const byte *)ptr;
    385385                return (b[3] << 24) + (b[2] << 16) + (b[1] << 8) + (b[0]);
    386386        }
    387387
    388         FORCEINLINE uint32 READ_BE_UINT32(const void *ptr) {
    389                 return *(const uint32 *)(ptr);
    390         }
    391 
    392         FORCEINLINE uint READ_LE_UINT16(const void *ptr) {
    393                 const byte *b = (const byte *)ptr;
    394                 return (b[1] << 8) + b[0];
    395         }
     388        #if defined(SCUMM_NEED_ALIGNMENT)
     389                FORCEINLINE uint32 READ_BE_UINT32(const void *ptr) {
     390                        const byte *b = (const byte*)ptr;
     391                        return (b[0] << 24) + (b[1] << 16) + (b[2] << 8) + (b[3]);
     392                }
     393        #else
     394                FORCEINLINE uint32 READ_BE_UINT32(const void *ptr) {
     395                        return *(const uint32 *)(ptr);
     396                }
     397        #endif
    396398
    397         FORCEINLINE uint READ_BE_UINT16(const void *ptr) {
    398                 return *(const uint16 *)(ptr);
     399        FORCEINLINE uint32 FROM_LE_32(uint32 a) {
     400                return ((a >> 24) & 0xFF) + ((a >> 8) & 0xFF00) + (( a<< 8) & 0xFF0000) \
     401                                                + ((a<<24)&0xFF000000);
    399402        }
    400403
    401         FORCEINLINE uint READ_BE_UINT16_UNALIGNED(const void *ptr) {
    402                 return (((const byte *)ptr)[0] << 8)|((const byte *)ptr)[1];
     404        FORCEINLINE uint16 FROM_LE_16(uint16 a) {
     405                return ((a >> 8) & 0xFF) + ((a << 8) & 0xFF00);
    403406        }
    404407
    405         FORCEINLINE uint32 READ_BE_UINT32_UNALIGNED(const void *ptr) {
    406                 const byte *b = (const byte*)ptr;
    407                 return (b[0] << 24) + (b[1] << 16) + (b[2] << 8) + (b[3]);
    408         }
     408        #define READ_UINT32(a) READ_BE_UINT32(a)
    409409
    410         #define READ_UINT32_UNALIGNED READ_BE_UINT32_UNALIGNED
     410        #define TO_LE_32 FROM_LE_32
     411        #define TO_LE_16 FROM_LE_16
    411412
    412413        #define TO_BE_32(a) (a)
    413414        #define TO_BE_16(a) (a)

  • scummvm/scumm/akos.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/akos.cpp ScummVM+hack/scummvm/scumm/akos.cpp
    old new  
    255255        if (code != AKC_ComplexChan) {
    256256                off = akof + (code & 0xFFF);
    257257
    258                 assert((code & 0xFFF) * 6 < READ_BE_UINT32_UNALIGNED((const byte *)akof - 4) - 8);
     258                assert((code & 0xFFF) * 6 < READ_BE_UINT32((const byte *)akof - 4) - 8);
    259259                assert((code & 0x7000) == 0);
    260260
    261261                _srcptr = akcd + READ_LE_UINT32(&off->akcd);

  • scummvm/scumm/gfx.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/gfx.cpp ScummVM+hack/scummvm/scumm/gfx.cpp
    old new  
    26192619
    26202620                ptr += 2;
    26212621                cycl->counter = 0;
    2622                 cycl->delay = 16384 / READ_BE_UINT16_UNALIGNED(ptr);
     2622                cycl->delay = 16384 / READ_BE_UINT16(ptr);
    26232623                ptr += 2;
    2624                 cycl->flags = READ_BE_UINT16_UNALIGNED(ptr);
     2624                cycl->flags = READ_BE_UINT16(ptr);
    26252625                ptr += 2;
    26262626                cycl->start = *ptr++;
    26272627                cycl->end = *ptr++;

  • scummvm/scumm/imuse.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/imuse.cpp ScummVM+hack/scummvm/scumm/imuse.cpp
    old new  
    100100        }
    101101
    102102        ptr += 8;
    103         size = READ_BE_UINT32_UNALIGNED(ptr);
     103        size = READ_BE_UINT32(ptr);
    104104        ptr += 4;
    105105
    106106        // Okay, we're looking for one of those things: either

  • scummvm/scumm/imuse_digi.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/imuse_digi.cpp ScummVM+hack/scummvm/scumm/imuse_digi.cpp
    old new  
    803803
    804804                        uint32 tag, size = 0, r, t;
    805805
    806                         if (READ_UINT32_UNALIGNED(ptr) == MKID('Crea')) {
     806                        if (READ_UINT32(ptr) == MKID('Crea')) {
    807807                                _channel[l]._bits = 8;
    808808                                _channel[l]._channels = 2;
    809809                                _channel[l]._mixerSize = (22050 / 5) * 2;
    … …  
    827827                                }
    828828                                free(t_ptr);
    829829                                _channel[l]._size = size;
    830                         } else if (READ_UINT32_UNALIGNED(ptr) == MKID('iMUS')) {
     830                        } else if (READ_UINT32(ptr) == MKID('iMUS')) {
    831831                                ptr += 16;
    832832                                for (;;) {
    833                                         tag = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
     833                                        tag = READ_BE_UINT32(ptr); ptr += 4;
    834834                                        switch(tag) {
    835835                                                case MKID_BE('FRMT'):
    836836                                                        ptr += 12;
    837                                                         _channel[l]._bits = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
    838                                                         _channel[l]._freq = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
    839                                                         _channel[l]._channels = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
     837                                                        _channel[l]._bits = READ_BE_UINT32(ptr); ptr += 4;
     838                                                        _channel[l]._freq = READ_BE_UINT32(ptr); ptr += 4;
     839                                                        _channel[l]._channels = READ_BE_UINT32(ptr); ptr += 4;
    840840                                                break;
    841841                                                case MKID_BE('TEXT'):
    842                                                         size = READ_BE_UINT32_UNALIGNED(ptr); ptr += size + 4;
     842                                                        size = READ_BE_UINT32(ptr); ptr += size + 4;
    843843                                                break;
    844844                                                case MKID_BE('REGN'):
    845845                                                        ptr += 4;
    … …  
    848848                                                                ptr += 8;
    849849                                                                break;
    850850                                                        }
    851                                                         _channel[l]._region[_channel[l]._numRegions]._offset = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
    852                                                         _channel[l]._region[_channel[l]._numRegions]._length = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
     851                                                        _channel[l]._region[_channel[l]._numRegions]._offset = READ_BE_UINT32(ptr); ptr += 4;
     852                                                        _channel[l]._region[_channel[l]._numRegions]._length = READ_BE_UINT32(ptr); ptr += 4;
    853853                                                        _channel[l]._numRegions++;
    854854                                                break;
    855855                                                case MKID_BE('STOP'):
    856856                                                        ptr += 4;
    857                                                         _channel[l]._offsetStop = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
     857                                                        _channel[l]._offsetStop = READ_BE_UINT32(ptr); ptr += 4;
    858858                                                break;
    859859                                                case MKID_BE('JUMP'):
    860860                                                        ptr += 4;
    … …  
    863863                                                                ptr += 16;
    864864                                                                break;
    865865                                                        }
    866                                                         _channel[l]._jump[_channel[l]._numJumps]._offset = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
    867                                                         _channel[l]._jump[_channel[l]._numJumps]._dest = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
    868                                                         _channel[l]._jump[_channel[l]._numJumps]._id = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
    869                                                         _channel[l]._jump[_channel[l]._numJumps]._numLoops = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
     866                                                        _channel[l]._jump[_channel[l]._numJumps]._offset = READ_BE_UINT32(ptr); ptr += 4;
     867                                                        _channel[l]._jump[_channel[l]._numJumps]._dest = READ_BE_UINT32(ptr); ptr += 4;
     868                                                        _channel[l]._jump[_channel[l]._numJumps]._id = READ_BE_UINT32(ptr); ptr += 4;
     869                                                        _channel[l]._jump[_channel[l]._numJumps]._numLoops = READ_BE_UINT32(ptr); ptr += 4;
    870870                                                        _channel[l]._isJump = true;
    871871                                                        _channel[l]._numJumps++;
    872872                                                break;
    873873                                                case MKID_BE('DATA'):
    874                                                         size = READ_BE_UINT32_UNALIGNED(ptr); ptr += 4;
     874                                                        size = READ_BE_UINT32(ptr); ptr += 4;
    875875                                                break;
    876876                                                default:
    877877                                                        error("IMuseDigital::startSound(%d) Unknown sfx header %c%c%c%c", sound, (byte)(tag >> 24), (byte)(tag >> 16), (byte)(tag >> 8), (byte)tag);

  • scummvm/scumm/object.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/object.cpp ScummVM+hack/scummvm/scumm/object.cpp
    old new  
    973973        if (whereIsObject(obj) == WIO_FLOBJECT) {
    974974                i = getObjectIndex(obj);
    975975                ptr = getResourceAddress(rtFlObject, _objs[i].fl_object_index) + 8;
    976                 size = READ_BE_UINT32_UNALIGNED(ptr + 4);
     976                size = READ_BE_UINT32(ptr + 4);
    977977        } else {
    978978                findObjectInRoom(&foir, foCodeHeader, obj, room);
    979979                if (_features & GF_OLD_BUNDLE)
    … …  
    981981                else if (_features & GF_SMALL_HEADER)
    982982                        size = READ_LE_UINT32(foir.obcd);
    983983                else
    984                         size = READ_BE_UINT32_UNALIGNED(foir.obcd + 4);
     984                        size = READ_BE_UINT32(foir.obcd + 4);
    985985                ptr = foir.obcd;
    986986        }
    987987
    … …  
    13521352                if (dataptr == NULL)
    13531353                        error("setCursorImg: No such image");
    13541354       
    1355                 size = READ_BE_UINT32_UNALIGNED(dataptr + 4);
     1355                size = READ_BE_UINT32(dataptr + 4);
    13561356                if (size > sizeof(_grabbedCursor))
    13571357                        error("setCursorImg: Cursor image too large");
    13581358               
    … …  
    16281628        }
    16291629
    16301630        // Setup sizes
    1631         obcd_size = READ_BE_UINT32_UNALIGNED(foir.obcd + 4);
     1631        obcd_size = READ_BE_UINT32(foir.obcd + 4);
    16321632        od->OBCDoffset = 8;
    16331633        od->OBIMoffset = obcd_size + 8;
    1634         obim_size = READ_BE_UINT32_UNALIGNED(foir.obim + 4);
     1634        obim_size = READ_BE_UINT32(foir.obim + 4);
    16351635        flob_size = obcd_size + obim_size + 8;
    16361636
    16371637        // Lock room/roomScripts for the given room. They contains the OBCD/OBIM

  • scummvm/scumm/resource.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/resource.cpp ScummVM+hack/scummvm/scumm/resource.cpp
    old new  
    13661366        else if (_features & GF_SMALL_HEADER)
    13671367                return READ_LE_UINT32(ptr) - 6;
    13681368        else
    1369                 return READ_BE_UINT32_UNALIGNED(ptr - 4) - 8;
     1369                return READ_BE_UINT32(ptr - 4) - 8;
    13701370}
    13711371
    13721372struct FindResourceState {
    … …  
    13811381        FindResourceState *f = &frs;    /* easier to make it thread safe like this */
    13821382
    13831383        if (searchin) {
    1384                 f->size = READ_BE_UINT32_UNALIGNED(searchin + 4);
     1384                f->size = READ_BE_UINT32(searchin + 4);
    13851385                f->pos = 8;
    13861386                f->ptr = searchin + 8;
    13871387                goto StartScan;
    13881388        }
    13891389
    13901390        do {
    1391                 size = READ_BE_UINT32_UNALIGNED(f->ptr + 4);
     1391                size = READ_BE_UINT32(f->ptr + 4);
    13921392                if ((int32)size <= 0)
    13931393                        return NULL;
    13941394
    … …  
    13981398        StartScan:
    13991399                if (f->pos >= f->size)
    14001400                        return NULL;
    1401         } while (READ_UINT32_UNALIGNED(f->ptr) != tag);
     1401        } while (READ_UINT32(f->ptr) != tag);
    14021402
    14031403        return f->ptr;
    14041404}
    … …  
    14401440        assert(searchin);
    14411441
    14421442        searchin += 4;
    1443         totalsize = READ_BE_UINT32_UNALIGNED(searchin);
     1443        totalsize = READ_BE_UINT32(searchin);
    14441444        curpos = 8;
    14451445        searchin += 4;
    14461446
    14471447        while (curpos < totalsize) {
    1448                 if (READ_UINT32_UNALIGNED(searchin) == tag && !idx--)
     1448                if (READ_UINT32(searchin) == tag && !idx--)
    14491449                        return searchin;
    14501450
    1451                 size = READ_BE_UINT32_UNALIGNED(searchin + 4);
     1451                size = READ_BE_UINT32(searchin + 4);
    14521452                if ((int32)size <= 0) {
    14531453                        error("(%c%c%c%c) Not found in %d... illegal block len %d",
    14541454                                                tag & 0xFF, (tag >> 8) & 0xFF, (tag >> 16) & 0xFF, (tag >> 24) & 0xFF, 0, size);

  • scummvm/scumm/resource.h 

    diff -ur ScummVM+orig/scummvm/scumm/resource.h ScummVM+hack/scummvm/scumm/resource.h
    old new  
    3434#endif
    3535
    3636#define RES_DATA(x) (((const byte*)x) + sizeof(ResHdr))
    37 #define RES_SIZE(x) (READ_BE_UINT32_UNALIGNED(&((const ResHdr* )x)->size))
     37#define RES_SIZE(x) (READ_BE_UINT32(&((const ResHdr* )x)->size))
    3838
    3939enum {
    4040        OF_OWNER_MASK = 0x0F,

  • scummvm/scumm/script_v5.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/script_v5.cpp ScummVM+hack/scummvm/scumm/script_v5.cpp
    old new  
    19511951                assert(searchin);
    19521952       
    19531953                searchin += 4;
    1954                 totalsize = READ_BE_UINT32_UNALIGNED(searchin);
     1954                totalsize = READ_BE_UINT32(searchin);
    19551955                curpos = 8;
    19561956                searchin += 4;
    19571957       
    19581958                while (curpos < totalsize) {
    1959                         if (READ_UINT32_UNALIGNED(searchin) == tag) {
     1959                        if (READ_UINT32(searchin) == tag) {
    19601960                                name = searchin + _resourceHeaderSize;
    19611961                                break;
    19621962                        }
    19631963       
    1964                         size = READ_BE_UINT32_UNALIGNED(searchin + 4);
     1964                        size = READ_BE_UINT32(searchin + 4);
    19651965                        if ((int32)size <= 0) {
    19661966                                error("(%c%c%c%c) Not found in %d... illegal block len %d",
    19671967                                                        tag & 0xFF, (tag >> 8) & 0xFF, (tag >> 16) & 0xFF, (tag >> 24) & 0xFF, 0, size);

  • scummvm/scumm/scummvm.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/scummvm.cpp ScummVM+hack/scummvm/scumm/scummvm.cpp
    old new  
    17801780        else if (_features & GF_SMALL_HEADER)
    17811781                size = READ_LE_UINT32(ptr);
    17821782        else
    1783                 size = READ_BE_UINT32_UNALIGNED(ptr + 4);
     1783                size = READ_BE_UINT32(ptr + 4);
    17841784
    17851785#if defined(MACOS_CARBON)
    17861786        sprintf(buf, ":dumps:%s%d.dmp", tag, idx);

  • scummvm/scumm/sound.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/sound.cpp ScummVM+hack/scummvm/scumm/sound.cpp
    old new  
    180180        debug(3,"playSound #%d (room %d)", soundID, _scumm->getResourceRoomNr(rtSound, soundID));
    181181        ptr = _scumm->getResourceAddress(rtSound, soundID);
    182182        if (ptr) {
    183                 if (READ_UINT32_UNALIGNED(ptr) == MKID('iMUS')){
     183                if (READ_UINT32(ptr) == MKID('iMUS')){
    184184                        assert(_scumm->_imuseDigital);
    185185                        _scumm->_imuseDigital->startSound(soundID);
    186186                        return;
    187187                }
    188                 else if (READ_UINT32_UNALIGNED(ptr) == MKID('Crea')) {
     188                else if (READ_UINT32(ptr) == MKID('Crea')) {
    189189                        assert(_scumm->_imuseDigital);
    190190                        _scumm->_imuseDigital->startSound(soundID);
    191191                        return;
    192192                }
    193                 else if (READ_UINT32_UNALIGNED(ptr) == MKID('SOUN')) {
     193                else if (READ_UINT32(ptr) == MKID('SOUN')) {
    194194                        ptr += 8;
    195195                        _scumm->VAR(_scumm->VAR_MUSIC_TIMER) = 0;
    196196                        playCDTrack(ptr[16], ptr[17] == 0xff ? -1 : ptr[17],
    … …  
    202202                // Support for SFX in Monkey Island 1, Mac version
    203203                // This is rather hackish right now, but works OK. SFX are not sounding
    204204                // 100% correct, though, not sure right now what is causing this.
    205                 else if (READ_UINT32_UNALIGNED(ptr) == MKID('Mac1')) {
     205                else if (READ_UINT32(ptr) == MKID('Mac1')) {
    206206
    207207                        // Read info from the header
    208                         size = READ_BE_UINT32_UNALIGNED(ptr+0x60);
    209                         rate = READ_BE_UINT32_UNALIGNED(ptr+0x64) >> 16;
     208                        size = READ_BE_UINT32(ptr+0x60);
     209                        rate = READ_BE_UINT32(ptr+0x64) >> 16;
    210210
    211211                        // Skip over the header (fixed size)
    212212                        ptr += 0x72;
    … …  
    218218                        return;
    219219                }
    220220                // Support for Putt-Putt sounds - very hackish, too 8-)
    221                 else if (READ_UINT32_UNALIGNED(ptr) == MKID('DIGI')) {
     221                else if (READ_UINT32(ptr) == MKID('DIGI')) {
    222222                        // TODO - discover what data the first chunk, HSHD, contains
    223223                        // it might be useful here.
    224                         ptr += 8 + READ_BE_UINT32_UNALIGNED(ptr+12);
    225                         if (READ_UINT32_UNALIGNED(ptr) != MKID('SDAT'))
     224                        ptr += 8 + READ_BE_UINT32(ptr+12);
     225                        if (READ_UINT32(ptr) != MKID('SDAT'))
    226226                                return; // abort
    227227
    228                         size = READ_BE_UINT32_UNALIGNED(ptr+4) - 8;
     228                        size = READ_BE_UINT32(ptr+4) - 8;
    229229                        // FIXME - what value here ?!? 11025 is just a guess based on strings in w32 bin, prev guess 8000
    230230                        rate = 11025;
    231231
    … …  
    236236                        return;
    237237                }
    238238                // XMIDI
    239                 else if ((READ_UINT32_UNALIGNED(ptr) == MKID('MIDI')) && (_scumm->_features & GF_HUMONGOUS)) {
     239                else if ((READ_UINT32(ptr) == MKID('MIDI')) && (_scumm->_features & GF_HUMONGOUS)) {
    240240                        // Pass XMIDI on to IMuse unprocessed.
    241241                        // IMuse can handle XMIDI resources now.
    242242                }
    243                 else if (READ_UINT32_UNALIGNED(ptr) == MKID('ADL ')) {
     243                else if (READ_UINT32(ptr) == MKID('ADL ')) {
    244244                        // played as MIDI, just to make perhaps the later use
    245245                        // of WA possible (see "else if" with GF_OLD256 below)
    246246                }
    247247                // Support for sampled sound effects in Monkey1 and Monkey2
    248                 else if (READ_UINT32_UNALIGNED(ptr) == MKID('SBL ')) {
     248                else if (READ_UINT32(ptr) == MKID('SBL ')) {
    249249                        debug(2, "Using SBL sound effect");
    250250
    251251                        // TODO - Figuring out how the SBL chunk works. Here's
    … …  
    283283                        // I'm going to assume that the sample frequency is
    284284                        // the only important difference between the two.
    285285
    286                         if (READ_UINT32_UNALIGNED(ptr + 8) == MKID('WVhd'))
     286                        if (READ_UINT32(ptr + 8) == MKID('WVhd'))
    287287                                rate = 11025;
    288288                        else
    289289                                rate = 8000;
    290290
    291                         size = READ_BE_UINT32_UNALIGNED(ptr + 4) - 27;
     291                        size = READ_BE_UINT32(ptr + 4) - 27;
    292292
    293293                        // Allocate a sound buffer, copy the data into it, and play
    294294                        sound = (char *)malloc(size);

  • scummvm/scumm/verbs.cpp 

    diff -ur ScummVM+orig/scummvm/scumm/verbs.cpp ScummVM+hack/scummvm/scumm/verbs.cpp
    old new  
    558558                }
    559559        } else {
    560560                findObjectInRoom(&foir, foImageHeader, object, room);
    561                 size = READ_BE_UINT32_UNALIGNED(foir.obim + 4);
     561                size = READ_BE_UINT32(foir.obim + 4);
    562562                createResource(rtVerb, verb, size);
    563563                obimptr = getResourceAddress(rtRoom, room) - foir.roomptr + foir.obim;
    564564                memcpy(getResourceAddress(rtVerb, verb), obimptr, size);

  • scummvm/simon/charset.cpp 

    diff -ur ScummVM+orig/scummvm/simon/charset.cpp ScummVM+hack/scummvm/simon/charset.cpp
    old new  
    7979
    8080        *(uint16 *)(p + 4) = TO_BE_16(height);
    8181        *(uint16 *)(p + 6) = TO_BE_16(width);
    82         dst += READ_BE_UINT32_UNALIGNED(p);
     82        dst += READ_BE_UINT32(p);
    8383
    8484        memset(dst, 0, count);
    8585

  • scummvm/simon/debug.cpp 

    diff -ur ScummVM+orig/scummvm/simon/debug.cpp ScummVM+hack/scummvm/simon/debug.cpp
    old new  
    175175
    176176        do {
    177177                if (!(_game & GF_SIMON2)) {
    178                         opcode = READ_BE_UINT16_UNALIGNED(src);
     178                        opcode = READ_BE_UINT16(src);
    179179                        src += 2;
    180180                } else {
    181181                        opcode = *src++;
    … …  
    205205                                fprintf(_dump_file, "%d ", *src++);
    206206                                break;
    207207                        case 'd':
    208                                 fprintf(_dump_file, "%d ", READ_BE_UINT16_UNALIGNED(src));
     208                                fprintf(_dump_file, "%d ", READ_BE_UINT16(src));
    209209                                src += 2;
    210210                                break;
    211211                        case 'v':
    212                                 fprintf(_dump_file, "[%d] ", READ_BE_UINT16_UNALIGNED(src));
     212                                fprintf(_dump_file, "[%d] ", READ_BE_UINT16(src));
    213213                                src += 2;
    214214                                break;
    215215                        case 'i':
    216                                 fprintf(_dump_file, "%d ", (int16)READ_BE_UINT16_UNALIGNED(src));
     216                                fprintf(_dump_file, "%d ", (int16)READ_BE_UINT16(src));
    217217                                src += 2;
    218218                                break;
    219219                        case 'q':
    220                                 while (READ_BE_UINT16_UNALIGNED(src) != 999) {
    221                                         fprintf(_dump_file, "(%d,%d) ", READ_BE_UINT16_UNALIGNED(src),
    222                                                                         READ_BE_UINT16_UNALIGNED(src + 2));
     220                                while (READ_BE_UINT16(src) != 999) {
     221                                        fprintf(_dump_file, "(%d,%d) ", READ_BE_UINT16(src),
     222                                                                        READ_BE_UINT16(src + 2));
    223223                                        src += 4;
    224224                                }
    225225                                src++;
    … …  
    240240                int count;
    241241
    242242                pp = vga;
    243                 p = pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header *) pp)->hdr2_start);
    244                 count = READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) p)->id_count);
    245                 p = pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) p)->id_table);
     243                p = pp + READ_BE_UINT16(&((VgaFile1Header *) pp)->hdr2_start);
     244                count = READ_BE_UINT16(&((VgaFile1Header2 *) p)->id_count);
     245                p = pp + READ_BE_UINT16(&((VgaFile1Header2 *) p)->id_table);
    246246                while (--count >= 0) {
    247                         int id = READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6 *) p)->id);
     247                        int id = READ_BE_UINT16(&((VgaFile1Struct0x6 *) p)->id);
    248248
    249                         dump_vga_script_always(vga + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6 *) p)->script_offs), id / 100, id);
     249                        dump_vga_script_always(vga + READ_BE_UINT16(&((VgaFile1Struct0x6 *) p)->script_offs), id / 100, id);
    250250                        p += sizeof(VgaFile1Struct0x6);
    251251                }
    252252        }
    … …  
    256256                int c;
    257257
    258258                bb = vga;
    259                 b = bb + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header *) bb)->hdr2_start);
    260                 c = READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) b)->unk1);
    261                 b = bb + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) b)->unk2_offs);
     259                b = bb + READ_BE_UINT16(&((VgaFile1Header *) bb)->hdr2_start);
     260                c = READ_BE_UINT16(&((VgaFile1Header2 *) b)->unk1);
     261                b = bb + READ_BE_UINT16(&((VgaFile1Header2 *) b)->unk2_offs);
    262262
    263263                while (--c >= 0) {
    264                         int id = READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x8 *) b)->id);
     264                        int id = READ_BE_UINT16(&((VgaFile1Struct0x8 *) b)->id);
    265265
    266                         dump_vga_script_always(vga + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x8 *) b)->script_offs), id / 100, id);
     266                        dump_vga_script_always(vga + READ_BE_UINT16(&((VgaFile1Struct0x8 *) b)->script_offs), id / 100, id);
    267267                        b += sizeof(VgaFile1Struct0x8);
    268268                }
    269269        }

  • scummvm/simon/simon.cpp 

    diff -ur ScummVM+orig/scummvm/simon/simon.cpp ScummVM+hack/scummvm/simon/simon.cpp
    old new  
    22482248        // ensure flipping complete
    22492249
    22502250        bb = _cur_vga_file_1;
    2251         b = bb + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header *) bb)->hdr2_start);
    2252         c = READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) b)->unk1);
    2253         b = bb + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) b)->unk2_offs);
     2251        b = bb + READ_BE_UINT16(&((VgaFile1Header *) bb)->hdr2_start);
     2252        c = READ_BE_UINT16(&((VgaFile1Header2 *) b)->unk1);
     2253        b = bb + READ_BE_UINT16(&((VgaFile1Header2 *) b)->unk2_offs);
    22542254
    2255         while (READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x8 *) b)->id) != vga_res_id)
     2255        while (READ_BE_UINT16(&((VgaFile1Struct0x8 *) b)->id) != vga_res_id)
    22562256                b += sizeof(VgaFile1Struct0x8);
    22572257
    22582258        if (!(_game & GF_SIMON2)) {
    … …  
    22722272
    22732273        vc_ptr_org = _vc_ptr;
    22742274
    2275         _vc_ptr = _cur_vga_file_1 + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x8 *) b)->script_offs);
     2275        _vc_ptr = _cur_vga_file_1 + READ_BE_UINT16(&((VgaFile1Struct0x8 *) b)->script_offs);
    22762276        //dump_vga_script(_vc_ptr, num, vga_res_id);
    22772277        run_vga_script();
    22782278        _vc_ptr = vc_ptr_org;
    … …  
    27952795                _video_palette_mode = vsp->unk6;
    27962796                _vga_cur_sprite_id = vsp->id;
    27972797
    2798                 params[0] = READ_BE_UINT16_UNALIGNED(&vsp->image);
    2799                 params[1] = READ_BE_UINT16_UNALIGNED(&vsp->base_color);
    2800                 params[2] = READ_BE_UINT16_UNALIGNED(&vsp->x);
    2801                 params[3] = READ_BE_UINT16_UNALIGNED(&vsp->y);
     2798                params[0] = READ_BE_UINT16(&vsp->image);
     2799                params[1] = READ_BE_UINT16(&vsp->base_color);
     2800                params[2] = READ_BE_UINT16(&vsp->x);
     2801                params[3] = READ_BE_UINT16(&vsp->y);
    28022802
    28032803                if (_game & GF_SIMON2) {
    28042804                        *(byte *)(&params[4]) = (byte)vsp->unk4;
    28052805                } else {
    2806                         params[4] = READ_BE_UINT16_UNALIGNED(&vsp->unk4);
     2806                        params[4] = READ_BE_UINT16(&vsp->unk4);
    28072807                }
    28082808
    28092809                _vc_ptr = (byte *)params;
    … …  
    28372837        }
    28382838
    28392839        src = _vga_var7 + x * 4;
    2840         decodeStripA(dst, src + READ_BE_UINT32_UNALIGNED(&*((uint32 *)src)), _vga_var5);
     2840        decodeStripA(dst, src + READ_BE_UINT32(&*((uint32 *)src)), _vga_var5);
    28412841
    28422842        dx_unlock_2();
    28432843
    … …  
    28752875                if (vsp->image)
    28762876                        fprintf(_dump_file, "id:%5d image:%3d base-color:%3d x:%3d y:%3d flags:%x\n",
    28772877                                                        vsp->id, vsp->image, vsp->base_color, vsp->x, vsp->y, vsp->unk4);
    2878                 params[0] = READ_BE_UINT16_UNALIGNED(&vsp->image);
    2879                 params[1] = READ_BE_UINT16_UNALIGNED(&vsp->base_color);
    2880                 params[2] = READ_BE_UINT16_UNALIGNED(&vsp->x);
    2881                 params[3] = READ_BE_UINT16_UNALIGNED(&vsp->y);
    2882                 params[4] = READ_BE_UINT16_UNALIGNED(&vsp->unk4);
     2878                params[0] = READ_BE_UINT16(&vsp->image);
     2879                params[1] = READ_BE_UINT16(&vsp->base_color);
     2880                params[2] = READ_BE_UINT16(&vsp->x);
     2881                params[3] = READ_BE_UINT16(&vsp->y);
     2882                params[4] = READ_BE_UINT16(&vsp->unk4);
    28832883                _vc_ptr = (byte *)params;
    28842884                vc_10_draw();
    28852885
    … …  
    31083108                p = (uint16 *)_pathfind_array[20 - i];
    31093109                if (!p)
    31103110                        continue;
    3111                 for (j = 0; READ_BE_UINT16_UNALIGNED(&p[0]) != 999; j++, p += 2) {      // 0xE703 = byteswapped 999
    3112                         x_diff = abs((int)(READ_BE_UINT16_UNALIGNED(&p[0]) - x));
    3113                         y_diff = abs((int)(READ_BE_UINT16_UNALIGNED(&p[1]) - 12 - y));
     3111                for (j = 0; READ_BE_UINT16(&p[0]) != 999; j++, p += 2) {        // 0xE703 = byteswapped 999
     3112                        x_diff = abs((int)(READ_BE_UINT16(&p[0]) - x));
     3113                        y_diff = abs((int)(READ_BE_UINT16(&p[1]) - 12 - y));
    31143114
    31153115                        if (x_diff < y_diff) {
    31163116                                x_diff >>= 2;
    … …  
    37143714        }
    37153715
    37163716        pp = _cur_vga_file_1;
    3717         p = pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header *) pp)->hdr2_start);
     3717        p = pp + READ_BE_UINT16(&((VgaFile1Header *) pp)->hdr2_start);
    37183718
    3719         count = READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) p)->id_count);
    3720         p = pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) p)->id_table);
     3719        count = READ_BE_UINT16(&((VgaFile1Header2 *) p)->id_count);
     3720        p = pp + READ_BE_UINT16(&((VgaFile1Header2 *) p)->id_table);
    37213721
    37223722        for (;;) {
    3723                 if (READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6 *) p)->id) == vga_struct_id) {
     3723                if (READ_BE_UINT16(&((VgaFile1Struct0x6 *) p)->id) == vga_struct_id) {
    37243724
    3725                         //dump_vga_script(pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6*)p)->script_offs), vga_res, vga_struct_id);
     3725                        //dump_vga_script(pp + READ_BE_UINT16(&((VgaFile1Struct0x6*)p)->script_offs), vga_res, vga_struct_id);
    37263726
    3727                         add_vga_timer(gss->VGA_DELAY_BASE, pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6 *) p)->script_offs), vga_struct_id, vga_res);
     3727                        add_vga_timer(gss->VGA_DELAY_BASE, pp + READ_BE_UINT16(&((VgaFile1Struct0x6 *) p)->script_offs), vga_struct_id, vga_res);
    37283728                        break;
    37293729                }
    37303730                p += sizeof(VgaFile1Struct0x6);

  • scummvm/simon/vga.cpp 

    diff -ur ScummVM+orig/scummvm/simon/vga.cpp ScummVM+hack/scummvm/simon/vga.cpp
    old new  
    120120                }
    121121
    122122                if (!(_game & GF_SIMON2)) {
    123                         opcode = READ_BE_UINT16_UNALIGNED(_vc_ptr);
     123                        opcode = READ_BE_UINT16(_vc_ptr);
    124124                        _vc_ptr += 2;
    125125                } else {
    126126                        opcode = *_vc_ptr++;
    … …  
    144144}
    145145
    146146uint SimonEngine::vc_read_next_word() {
    147         uint a = READ_BE_UINT16_UNALIGNED(_vc_ptr);
     147        uint a = READ_BE_UINT16(_vc_ptr);
    148148        _vc_ptr += 2;
    149149        return a;
    150150}
    … …  
    245245
    246246
    247247        bb = _cur_vga_file_1;
    248         b = bb + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header *) bb)->hdr2_start);
    249         b = bb + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) b)->unk2_offs);
     248        b = bb + READ_BE_UINT16(&((VgaFile1Header *) bb)->hdr2_start);
     249        b = bb + READ_BE_UINT16(&((VgaFile1Header2 *) b)->unk2_offs);
    250250
    251         while (READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x8 *) b)->id) != num)
     251        while (READ_BE_UINT16(&((VgaFile1Struct0x8 *) b)->id) != num)
    252252                b += sizeof(VgaFile1Struct0x8);
    253253
    254254        vc_ptr_org = _vc_ptr;
    255255
    256         _vc_ptr = _cur_vga_file_1 + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x8 *) b)->script_offs);
     256        _vc_ptr = _cur_vga_file_1 + READ_BE_UINT16(&((VgaFile1Struct0x8 *) b)->script_offs);
    257257
    258258        //dump_vga_script(_vc_ptr, res, num);
    259259        run_vga_script();
    … …  
    317317        }
    318318
    319319        pp = _cur_vga_file_1;
    320         p = pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header *) pp)->hdr2_start);
    321         p = pp + READ_BE_UINT16_UNALIGNED(&((VgaFile1Header2 *) p)->id_table);
     320        p = pp + READ_BE_UINT16(&((VgaFile1Header *) pp)->hdr2_start);
     321        p = pp + READ_BE_UINT16(&((VgaFile1Header2 *) p)->id_table);
    322322
    323         while (READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6 *) p)->id) != b)
     323        while (READ_BE_UINT16(&((VgaFile1Struct0x6 *) p)->id) != b)
    324324                p += sizeof(VgaFile1Struct0x6);
    325325
    326326#ifdef DUMP_FILE_NR
    … …  
    343343        }
    344344#endif
    345345
    346         //dump_vga_script(_cur_vga_file_1 + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6*)p)->script_offs), res, b);
     346        //dump_vga_script(_cur_vga_file_1 + READ_BE_UINT16(&((VgaFile1Struct0x6*)p)->script_offs), res, b);
    347347
    348         add_vga_timer(gss->VGA_DELAY_BASE, _cur_vga_file_1 + READ_BE_UINT16_UNALIGNED(&((VgaFile1Struct0x6 *) p)->script_offs), b, res);
     348        add_vga_timer(gss->VGA_DELAY_BASE, _cur_vga_file_1 + READ_BE_UINT16(&((VgaFile1Struct0x6 *) p)->script_offs), b, res);
    349349}
    350350
    351351void SimonEngine::vc_4_dummy_op() {
    … …  
    599599                state.image = vc_read_var(-state.image);
    600600
    601601        p2 = _cur_vga_file_2 + state.image * 8;
    602         state.depack_src = _cur_vga_file_2 + READ_BE_UINT32_UNALIGNED(&*(uint32 *)p2);
     602        state.depack_src = _cur_vga_file_2 + READ_BE_UINT32(&*(uint32 *)p2);
    603603
    604         width = READ_BE_UINT16_UNALIGNED(p2 + 6) >> 4;
     604        width = READ_BE_UINT16(p2 + 6) >> 4;
    605605        height = p2[5];
    606606        flags = p2[4];
    607607
    … …  
    640640                src = state.depack_src + _x_scroll * 4;
    641641
    642642                for (w = 0; w < 40; w++) {
    643                         decodeStripA(dst, src + READ_BE_UINT32_UNALIGNED(&*(uint32 *)src), height);
     643                        decodeStripA(dst, src + READ_BE_UINT32(&*(uint32 *)src), height);
    644644                        dst += 8;
    645645                        src += 4;
    646646                }
    … …  
    10311031void SimonEngine::vc_17_set_pathfind_item() {
    10321032        uint a = vc_read_next_word();
    10331033        _pathfind_array[a - 1] = (uint16 *)_vc_ptr;
    1034         while (READ_BE_UINT16_UNALIGNED(_vc_ptr) != 999)
     1034        while (READ_BE_UINT16(_vc_ptr) != 999)
    10351035                _vc_ptr += 4;
    10361036        _vc_ptr += 2;
    10371037}
    … …  
    14831483        vp = &_variableArray[20];
    14841484
    14851485        do {
    1486                 y2 = READ_BE_UINT16_UNALIGNED(p);
     1486                y2 = READ_BE_UINT16(p);
    14871487                p += step;
    1488                 y1 = READ_BE_UINT16_UNALIGNED(p) - y2;
     1488                y1 = READ_BE_UINT16(p) - y2;
    14891489
    14901490                vp[0] = y1 >> 1;
    14911491                vp[1] = y1 - (y1 >> 1);
    … …  
    17381738                                        _cur_vga_file_2 = vpe->vgaFile2;
    17391739                                        _video_palette_mode = vsp->unk6;
    17401740
    1741                                         params[0] = READ_BE_UINT16_UNALIGNED(&vsp->image);
    1742                                         params[1] = READ_BE_UINT16_UNALIGNED(&vsp->base_color);
    1743                                         params[2] = READ_BE_UINT16_UNALIGNED(&vsp->x);
    1744                                         params[3] = READ_BE_UINT16_UNALIGNED(&vsp->y);
    1745                                         params[4] = READ_BE_UINT16_UNALIGNED(&vsp->unk4);
     1741                                        params[0] = READ_BE_UINT16(&vsp->image);
     1742                                        params[1] = READ_BE_UINT16(&vsp->base_color);
     1743                                        params[2] = READ_BE_UINT16(&vsp->x);
     1744                                        params[3] = READ_BE_UINT16(&vsp->y);
     1745                                        params[4] = READ_BE_UINT16(&vsp->unk4);
    17461746                                        _vc_ptr = (byte *)params;
    17471747                                        vc_10_draw();
    17481748