Ticket #8545: dxa-unification.diff

File dxa-unification.diff, 16.4 KB (added by eriktorbjorn, 13 years ago)

Patch against current SVN

  • engines/scumm/he/animation_he.h

     
    2525#define ANIMATION_H
    2626
    2727#include "common/file.h"
     28#include "graphics/animation.h"
    2829
    2930namespace Scumm {
    3031
    3132class ScummEngine_v90he;
    3233
    33 class MoviePlayer {
     34class MoviePlayer : public Graphics::DXAPlayer {
    3435        ScummEngine_v90he *_vm;
    3536
    36         Common::File _fd;
    37         uint8 *_frameBuffer1;
    38         uint8 *_frameBuffer2;
    39         uint16 _width;
    40         uint16 _height;
    41         uint16 _framesCount;
    42         uint32 _framesPerSec;
    43         uint16 _frameNum;
    44         uint32 _frameSize;
    45         uint32 _frameTicks;
    46 
    4737        uint32 _flags;
    4838        uint32 _wizResNum;
    4939       
    5040public:
    5141        MoviePlayer(ScummEngine_v90he *vm);
    52         ~MoviePlayer();
    5342
    54         int getWidth();
    55         int getHeight();
    56         int getCurFrame();
    57         int getFrameCount();
    5843        int getImageNum();
    5944        int load(const char *filename, int flags, int image = 0);
    6045
    6146        void handleNextFrame();
    6247        void close();
    6348
    64 private:
    65         void copyFrame(byte *dst, uint x, uint y);
    66         void decodeFrame();
    67         void decodeZlib(uint8 *data, int size, int totalSize);
     49protected:
     50        virtual void setPalette(byte *pal);
    6851};
    6952
    7053} // End of namespace Simon
  • engines/scumm/he/animation_he.cpp

     
    2626#include "scumm/he/animation_he.h"
    2727#include "scumm/he/intern_he.h"
    2828
    29 #ifdef USE_ZLIB
    30 #include <zlib.h>
    31 #endif
    32 
    3329namespace Scumm {
    3430
    3531MoviePlayer::MoviePlayer(ScummEngine_v90he *vm)
    36         : _vm(vm) {
     32        : DXAPlayer(), _vm(vm) {
    3733
    38         _frameBuffer1 = 0;
    39         _frameBuffer2 = 0;
    40 
    41         _width = 0;
    42         _height = 0;
    43 
    44         _frameSize = 0;
    45         _framesCount = 0;
    46         _frameNum = 0;
    47         _framesPerSec = 0;
    48         _frameTicks = 0;
    49 
    5034        _flags = 0;
    5135        _wizResNum = 0;
    5236}
    5337
    54 MoviePlayer::~MoviePlayer() {
    55 }
    56 
    57 int MoviePlayer::getWidth() {
    58         if (_fd.isOpen() == false)
    59                 return 0;
    60         return _width;
    61 }
    62 
    63 int MoviePlayer::getHeight() {
    64         if (_fd.isOpen() == false)
    65                 return 0;
    66         return _height;
    67 }
    68 
    69 int MoviePlayer::getCurFrame() {
    70         if (_fd.isOpen() == false)
    71                 return -1;
    72         return _frameNum;
    73 }
    74 
    75 int MoviePlayer::getFrameCount() {
    76         if (_fd.isOpen() == false)
    77                 return 0;
    78         return _framesCount;
    79 }
    80 
    8138int MoviePlayer::getImageNum() {
    8239        if (_fd.isOpen() == false)
    8340                return 0;
     
    174131                assert(dstPtr);
    175132                dst = _vm->findWrappedBlock(MKID_BE('WIZD'), dstPtr, 0, 0);
    176133                assert(dst);
    177                 copyFrame(dst, 0, 0);
     134                copyFrame(dst, 0, 0, _vm->_screenWidth);
    178135        } else if (_flags & 1) {
    179136                dst = pvs->getBackPixels(0, 0);
    180                 copyFrame(dst, 0, 0);
     137                copyFrame(dst, 0, 0, _vm->_screenWidth);
    181138               
    182139                Common::Rect imageRect(_width, _height);
    183140                _vm->gdi.copyVirtScreenBuffers(imageRect);
    184141        } else {
    185142                dst = pvs->getPixels(0, 0);
    186                 copyFrame(dst, 0, 0);
     143                copyFrame(dst, 0, 0, _vm->_screenWidth);
    187144
    188145                _vm->markRectAsDirty(kMainVirtScreen, 0, 0, _width, _height);
    189146        }
     
    194151        }
    195152}
    196153
    197 void MoviePlayer::copyFrame(byte *dst, uint x, uint y) {
    198         uint h = _height;
    199         uint w = _width;
    200 
    201         dst += y * _vm->_screenWidth + x;
    202         byte *src = _frameBuffer1;
    203 
    204         do {
    205                 memcpy(dst, src, w);
    206                 dst += _vm->_screenWidth;
    207                 src += _width;
    208         } while (--h);
     154void MoviePlayer::setPalette(byte *pal) {
     155        _vm->setPaletteFromPtr(pal, 256);
    209156}
    210157
    211 void MoviePlayer::decodeZlib(uint8 *data, int size, int totalSize) {
    212 #ifdef USE_ZLIB
    213         uint8 *temp = (uint8 *)malloc(size);
    214         if (temp) {
    215                 memcpy(temp, data, size);
    216         z_stream d_stream;
    217         d_stream.zalloc = (alloc_func)0;
    218         d_stream.zfree = (free_func)0;
    219         d_stream.opaque = (voidpf)0;
    220         d_stream.next_in = temp;
    221         d_stream.avail_in = size;
    222         d_stream.total_in = size;
    223         d_stream.next_out = data;
    224         d_stream.avail_out = totalSize;
    225         inflateInit(&d_stream);
    226         inflate(&d_stream, Z_FINISH);
    227         inflateEnd(&d_stream);
    228                 free(temp);
    229         }
    230 #endif
    231 }
    232 
    233 void MoviePlayer::decodeFrame() {
    234         uint32 tag;
    235 
    236         tag = _fd.readUint32BE();
    237         if (tag == MKID_BE('CMAP')) {
    238                 uint8 rgb[768];
    239 
    240                 _fd.read(rgb, ARRAYSIZE(rgb));
    241                 _vm->setPaletteFromPtr(rgb, 256);
    242         }
    243 
    244         tag = _fd.readUint32BE();
    245         if (tag == MKID_BE('FRAM')) {
    246                 uint8 type = _fd.readByte();
    247                 uint32 size = _fd.readUint32BE();
    248 
    249                 _fd.read(_frameBuffer2, size);
    250 
    251                 switch (type) {
    252                 case 2:
    253                 case 3:
    254                         decodeZlib(_frameBuffer2, size, _frameSize);
    255                         break;
    256                 default:
    257                         error("decodeFrame: Unknown compression type %d", type);
    258                 }
    259                 if (type == 2) {
    260                         memcpy(_frameBuffer1, _frameBuffer2, _frameSize);
    261                 } else {
    262                         for (int j = 0; j < _height; ++j) {
    263                                 for (int i = 0; i < _width; ++i) {
    264                                         const int offs = j * _width + i;
    265                                         _frameBuffer1[offs] ^= _frameBuffer2[offs];
    266                                 }
    267                         }
    268                 }
    269         }
    270 }
    271 
    272158} // End of namespace Simon
  • engines/simon/animation.h

     
    2727#include "common/file.h"
    2828#include "common/stream.h"
    2929
     30#include "graphics/animation.h"
    3031#include "sound/mixer.h"
    3132
    3233namespace Simon {
    3334
    3435class SimonEngine;
    3536
    36 class MoviePlayer {
     37class MoviePlayer : public Graphics::DXAPlayer {
    3738        SimonEngine *_vm;
    3839
    3940        Audio::Mixer *_mixer;
     
    4546        bool _playing;
    4647        bool _leftButtonDown;
    4748        bool _rightButtonDown;
    48         Common::File _fd;
    49         uint8 *_frameBuffer1;
    50         uint8 *_frameBuffer2;
    51         uint16 _width;
    52         uint16 _height;
    53         uint16 _framesCount;
    54         uint32 _framesPerSec;
    55         uint16 _frameNum;
    56         uint32 _frameSize;
    5749        uint16 _frameSkipped;
    58         uint32 _frameTicks;
    5950        uint32 _ticks;
    6051       
    6152        char baseName[40];
     
    6354        uint8 _sequenceNum;
    6455public:
    6556        MoviePlayer(SimonEngine *vm, Audio::Mixer *mixer);
    66         ~MoviePlayer();
    6757
    6858        bool load(const char *filename);
    6959        void play();
    7060        void nextFrame();
     61protected:
     62        virtual void setPalette(byte *pal);
    7163private:
    7264        void playOmniTV();
    7365        void close();
    7466
    75         void copyFrame(byte *dst, uint x, uint y);
    76         void decodeFrame();
    7767        void handleNextFrame();
    7868        void processFrame();
    7969        void startSound();
    80         void decodeZlib(uint8 *data, int size, int totalSize);
    8170};
    8271
    8372} // End of namespace Simon
  • engines/simon/animation.cpp

     
    3535#include "sound/audiostream.h"
    3636#include "sound/wave.h"
    3737
    38 
    39 #ifdef USE_ZLIB
    40 #include <zlib.h>
    41 #endif
    42 
    4338namespace Simon {
    4439
    4540MoviePlayer::MoviePlayer(SimonEngine *vm, Audio::Mixer *mixer)
    46         : _vm(vm), _mixer(mixer) {
     41        : DXAPlayer(), _vm(vm), _mixer(mixer) {
    4742        _omniTV = false;
    4843        _playing = false;
    4944
    5045        _leftButtonDown = false;
    5146        _rightButtonDown = false;
    5247
    53         _frameBuffer1 = 0;
    54         _frameBuffer2 = 0;
    55 
    56         _width = 0;
    57         _height = 0;
    58 
    59         _frameSize = 0;
    60         _framesCount = 0;
    61         _frameNum = 0;
    62         _framesPerSec = 0;
    63         _frameTicks = 0;
    6448        _frameSkipped = 0;
    6549
    6650        memset(baseName, 0, sizeof(baseName));
     
    6953        _ticks = 0;
    7054}
    7155
    72 MoviePlayer::~MoviePlayer() {
    73 }
    74 
    7556bool MoviePlayer::load(const char *filename) {
    7657        char videoName[20];
    7758        uint32 tag;
     
    276257        }
    277258
    278259        if (_mixer->isSoundHandleActive(_bgSound) && (_mixer->getSoundElapsedTime(_bgSound) * _framesPerSec) / 1000 < _frameNum) {
    279                 copyFrame(_vm->getBackBuf(), 465, 222);
     260                copyFrame(_vm->getBackBuf(), 465, 222, _vm->_screenWidth);
    280261                return;
    281262        }
    282263
    283264        if (_frameNum < _framesCount) {
    284265                decodeFrame();
    285                 copyFrame(_vm->getBackBuf(), 465, 222);
     266                copyFrame(_vm->getBackBuf(), 465, 222, _vm->_screenWidth);
    286267                _frameNum++;
    287268        } else {
    288269                _omniTV = false;
     
    332313        }
    333314}
    334315
    335 void MoviePlayer::copyFrame(byte *dst, uint x, uint y) {
    336         uint h = _height;
    337         uint w = _width;
     316void MoviePlayer::setPalette(byte *pal) {
     317        byte palette[1024];
     318        byte *p = palette;
    338319
    339         dst += y * _vm->_screenWidth + x;
    340         byte *src = _frameBuffer1;
    341 
    342         do {
    343                 memcpy(dst, src, w);
    344                 dst += _vm->_screenWidth;
    345                 src += _width;
    346         } while (--h);
    347 }
    348 
    349 void MoviePlayer::decodeZlib(uint8 *data, int size, int totalSize) {
    350 #ifdef USE_ZLIB
    351         uint8 *temp = (uint8 *)malloc(size);
    352         if (temp) {
    353                 memcpy(temp, data, size);
    354         z_stream d_stream;
    355         d_stream.zalloc = (alloc_func)0;
    356         d_stream.zfree = (free_func)0;
    357         d_stream.opaque = (voidpf)0;
    358         d_stream.next_in = temp;
    359         d_stream.avail_in = size;
    360         d_stream.total_in = size;
    361         d_stream.next_out = data;
    362         d_stream.avail_out = totalSize;
    363         inflateInit(&d_stream);
    364         inflate(&d_stream, Z_FINISH);
    365         inflateEnd(&d_stream);
    366                 free(temp);
     320        for (int i = 0; i <= 256; i++) {
     321                *p++ = *pal++;
     322                *p++ = *pal++;
     323                *p++ = *pal++;
     324                *p++ = 0;
    367325        }
    368 #endif
    369 }
    370326
    371 void MoviePlayer::decodeFrame() {
    372         uint32 tag;
    373 
    374         tag = _fd.readUint32BE();
    375         if (tag == MKID_BE('CMAP')) {
    376                 uint8 rgb[768];
    377                 byte palette[1024];
    378                 byte *p = palette;
    379 
    380                 _fd.read(rgb, ARRAYSIZE(rgb));
    381                 for (int i = 0; i <= 256; i++) {
    382                         *p++ = rgb[i * 3 + 0];
    383                         *p++ = rgb[i * 3 + 1];
    384                         *p++ = rgb[i * 3 + 2];
    385                         *p++ = 0;
    386                 }
    387                 _vm->_system->setPalette(palette, 0, 256);
    388         }
    389 
    390         tag = _fd.readUint32BE();
    391         if (tag == MKID_BE('FRAM')) {
    392                 uint8 type = _fd.readByte();
    393                 uint32 size = _fd.readUint32BE();
    394                 debug(5, "frame %d type %d size %d", _frameNum, type, size);
    395 
    396                 _fd.read(_frameBuffer2, size);
    397 
    398                 switch (type) {
    399                 case 2:
    400                 case 3:
    401                         decodeZlib(_frameBuffer2, size, _frameSize);
    402                         break;
    403                 default:
    404                         error("decodeFrame: Unknown compression type %d", type);
    405                 }
    406                 if (type == 2) {
    407                         memcpy(_frameBuffer1, _frameBuffer2, _frameSize);
    408                 } else {
    409                         for (int j = 0; j < _height; ++j) {
    410                                 for (int i = 0; i < _width; ++i) {
    411                                         const int offs = j * _width + i;
    412                                         _frameBuffer1[offs] ^= _frameBuffer2[offs];
    413                                 }
    414                         }
    415                 }
    416         }
     327        _vm->_system->setPalette(palette, 0, 256);
    417328}
    418329
    419330void MoviePlayer::processFrame() {
    420         copyFrame(_vm->getFrontBuf(), (_vm->_screenWidth - _width) / 2, (_vm->_screenHeight - _height) / 2);
     331        copyFrame(_vm->getFrontBuf(), (_vm->_screenWidth - _width) / 2, (_vm->_screenHeight - _height) / 2, _vm->_screenWidth);
    421332        _vm->_system->copyRectToScreen(_vm->getFrontBuf(), _vm->_screenWidth, 0, 0, _vm->_screenWidth, _vm->_screenHeight);
    422333
    423334        if ((_bgSoundStream == NULL) || ((int)(_mixer->getSoundElapsedTime(_bgSound) * _framesPerSec) / 1000 < _frameNum + 1) ||
  • graphics/animation.cpp

     
    2121 */
    2222
    2323#include "common/stdafx.h"
     24#include "common/endian.h"
    2425#include "graphics/animation.h"
    2526#include "sound/audiostream.h"
    2627#include "common/config-manager.h"
     
    2930#include "common/util.h"
    3031#include "graphics/scaler/intern.h"
    3132
     33#ifdef USE_ZLIB
     34#include <zlib.h>
     35#endif
     36
    3237namespace Graphics {
    3338
    3439BaseAnimationState::BaseAnimationState(Audio::Mixer *snd, OSystem *sys, int width, int height)
     
    680685        _sys->updateScreen();
    681686}
    682687
     688DXAPlayer::DXAPlayer() {
     689        _frameBuffer1 = 0;
     690        _frameBuffer2 = 0;
     691
     692        _width = 0;
     693        _height = 0;
     694
     695        _frameSize = 0;
     696        _framesCount = 0;
     697        _frameNum = 0;
     698        _framesPerSec = 0;
     699        _frameTicks = 0;
     700}
     701
     702DXAPlayer::~DXAPlayer() {
     703}
     704
     705int DXAPlayer::getWidth() {
     706        if (_fd.isOpen() == false)
     707                return 0;
     708        return _width;
     709}
     710
     711int DXAPlayer::getHeight() {
     712        if (_fd.isOpen() == false)
     713                return 0;
     714        return _height;
     715}
     716
     717int DXAPlayer::getCurFrame() {
     718        if (_fd.isOpen() == false)
     719                return -1;
     720        return _frameNum;
     721}
     722
     723int DXAPlayer::getFrameCount() {
     724        if (_fd.isOpen() == false)
     725                return 0;
     726        return _framesCount;
     727}
     728
     729void DXAPlayer::copyFrame(byte *dst, uint x, uint y, uint pitch) {
     730        uint h = _height;
     731        uint w = _width;
     732
     733        dst += y * pitch + x;
     734        byte *src = _frameBuffer1;
     735
     736        do {
     737                memcpy(dst, src, w);
     738                dst += pitch;
     739                src += _width;
     740        } while (--h);
     741}
     742
     743void DXAPlayer::decodeZlib(byte *data, int size, int totalSize) {
     744#ifdef USE_ZLIB
     745        byte *temp = (byte *)malloc(size);
     746        if (temp) {
     747                memcpy(temp, data, size);
     748
     749                z_stream d_stream;
     750                d_stream.zalloc = (alloc_func)0;
     751                d_stream.zfree = (free_func)0;
     752                d_stream.opaque = (voidpf)0;
     753                d_stream.next_in = temp;
     754                d_stream.avail_in = size;
     755                d_stream.total_in = size;
     756                d_stream.next_out = data;
     757                d_stream.avail_out = totalSize;
     758                inflateInit(&d_stream);
     759                inflate(&d_stream, Z_FINISH);
     760                inflateEnd(&d_stream);
     761                free(temp);
     762        }
     763#endif
     764}
     765
     766#define BLOCKW 4
     767#define BLOCKH 4
     768
     769void DXAPlayer::decode12(byte *data, int size, int totalSize) {
     770#ifdef USE_ZLIB
     771        /* decompress the input data */
     772        decodeZlib(data, size, totalSize);
     773
     774        byte *dat = data;
     775        byte *frame2 = (byte *)malloc(totalSize);
     776
     777        memcpy(frame2, _frameBuffer1, totalSize);
     778
     779        for (int by = 0; by < _height; by += BLOCKH) {
     780                for (int bx = 0; bx < _width; bx += BLOCKW) {
     781                        byte type = *dat++;
     782                        byte *b2 = frame2 + bx + by * _width;
     783
     784                        switch (type) {
     785                        case 0:
     786                                break;
     787                        case 10:
     788                        case 11:
     789                        case 12:
     790                        case 13:
     791                        case 14:
     792                        case 15:
     793                        case 1: {
     794                                unsigned short diffMap;
     795                                if (type >= 10 && type <= 15) {
     796                                        static const struct { uint8 sh1, sh2; } shiftTbl[6] = {
     797                                                {0, 0}, {8, 0}, {8, 8}, {8, 4}, {4, 0}, {4, 4}
     798                                        };
     799                                        diffMap = ((*dat & 0xF0) << shiftTbl[type-10].sh1) |
     800                                                  ((*dat & 0x0F) << shiftTbl[type-10].sh2);
     801                                        dat++;
     802                                } else {
     803                                        diffMap = *(unsigned short*)dat;
     804                                        dat += 2;
     805                                }
     806
     807                                for (int yc = 0; yc < BLOCKH; yc++) {
     808                                        for (int xc = 0; xc < BLOCKW; xc++) {
     809                                                if (diffMap & 0x8000) {
     810                                                        b2[xc] = *dat++;
     811                                                }
     812                                                diffMap <<= 1;
     813                                        }
     814                                        b2 += _width;
     815                                }
     816                                break;
     817                        }
     818                        case 2: {
     819                                byte color = *dat++;
     820
     821                                for (int yc = 0; yc < BLOCKH; yc++) {
     822                                        for (int xc = 0; xc < BLOCKW; xc++) {
     823                                                b2[xc] = color;
     824                                        }
     825                                        b2 += _width;
     826                                }
     827                                break;
     828                        }
     829                        case 3: {
     830                                for (int yc = 0; yc < BLOCKH; yc++) {
     831                                        for (int xc = 0; xc < BLOCKW; xc++) {
     832                                                b2[xc] = *dat++;
     833                                        }
     834                                        b2 += _width;
     835                                }
     836                                break;
     837                        }
     838                        case 4: {
     839                                byte mbyte = *dat++;
     840                                int mx = (mbyte >> 4) & 0x07;
     841                                if (mbyte & 0x80)
     842                                        mx = -mx;
     843                                int my = mbyte & 0x07;
     844                                if (mbyte & 0x08)
     845                                        my = -my;
     846                                byte *b1 = _frameBuffer1 + (bx+mx) + (by+my) * _width;
     847                                for (int yc = 0; yc < BLOCKH; yc++) {
     848                                        memcpy(b2, b1, BLOCKW);
     849                                        b1 += _width;
     850                                        b2 += _width;
     851                                }
     852                                break;
     853                        }
     854                        case 5:
     855                                break;
     856                        }
     857                }
     858        }
     859
     860        memcpy(data, frame2, totalSize);
     861        free(frame2);
     862#endif
     863}
     864
     865void DXAPlayer::decodeFrame() {
     866        uint32 tag;
     867
     868        tag = _fd.readUint32BE();
     869        if (tag == MKID_BE('CMAP')) {
     870                byte rgb[768];
     871
     872                _fd.read(rgb, ARRAYSIZE(rgb));
     873                setPalette(rgb);
     874        }
     875
     876        tag = _fd.readUint32BE();
     877        if (tag == MKID_BE('FRAM')) {
     878                byte type = _fd.readByte();
     879                uint32 size = _fd.readUint32BE();
     880
     881                _fd.read(_frameBuffer2, size);
     882
     883                switch (type) {
     884                case 2:
     885                case 3:
     886                        decodeZlib(_frameBuffer2, size, _frameSize);
     887                        break;
     888#if 0
     889                case 4:
     890                case 5:
     891                        decode0(_frameBuffer2, size);
     892                        break;
     893                case 6:
     894                case 7:
     895                        decode2(_frameBuffer2, size, _frameSize);
     896                        break;
     897#endif
     898                case 12:
     899                        decode12(_frameBuffer2, size, _frameSize);
     900                        break;
     901                default:
     902                        error("decodeFrame: Unknown compression type %d", type);
     903                }
     904                if (type == 2 || type == 4 || type == 6 || type == 12) {
     905                        memcpy(_frameBuffer1, _frameBuffer2, _frameSize);
     906                } else {
     907                        for (int j = 0; j < _height; ++j) {
     908                                for (int i = 0; i < _width; ++i) {
     909                                        const int offs = j * _width + i;
     910                                        _frameBuffer1[offs] ^= _frameBuffer2[offs];
     911                                }
     912                        }
     913                }
     914        }
     915}
     916
    683917} // End of namespace Graphics
  • graphics/animation.h

     
    2424#define GRAPHICS_ANIMATION_H
    2525
    2626#include "common/scummsys.h"
     27#include "common/file.h"
     28
    2729#include "sound/mixer.h"
    2830
    2931namespace Audio {
     
    156158#endif
    157159};
    158160
     161class DXAPlayer {
     162protected:
     163        Common::File _fd;
    159164
     165        byte *_frameBuffer1;
     166        byte *_frameBuffer2;
     167        uint16 _width;
     168        uint16 _height;
     169        uint16 _framesCount;
     170        uint32 _framesPerSec;
     171        uint16 _frameNum;
     172        uint32 _frameSize;
     173        uint32 _frameTicks;
     174
     175public:
     176        DXAPlayer();
     177        virtual ~DXAPlayer();
     178
     179        int getWidth();
     180        int getHeight();
     181        int getCurFrame();
     182        int getFrameCount();
     183
     184protected:
     185        virtual void setPalette(byte *pal) = 0;
     186
     187        void copyFrame(byte *dst, uint x, uint y, uint pitch);
     188        void decodeFrame();
     189        void decodeZlib(byte *data, int size, int totalSize);
     190        void decode12(byte *data, int size, int totalSize);
     191};
     192 
    160193} // End of namespace Graphics
    161194
    162195#endif