Ticket #8396: smush-speed.txt

Hello,

I have an update for the scumm smush_player and chunk class.
The old smush player was fairly excelent on fast computers
wheere seek / and transfer times are very short. On the other hand
if smush player was not fed properly right from the start (mostly
happens on platforms where there is no read-ahead file caching, and on 
platforms where data transfer rate is slow - flash disks etc.) then
the playback performace suffer. Another glitch concerned the 
time-compression on the start of the movie (first 2 or 3 seconds
of the movie were missing - or played back at once with stacked voice 
streams) is also solved.

This fix/update adds read-ahead caching to the chunk class
(I have created CachedFileChunk from the FileChunk) and slightly
modifies the smush_player.

I'm sorry that the source is attached here, but I have no other 
easier way how to contribute.

Hope it will be usefull.

Ole



chunk.h
-----------------------------------------------------------
class CachedFileChunk : public BaseChunk {
private:
        ScummFile *_data;
        uint32 _offset;

        unsigned char*  _cache;    //read ahead cache
        uint32 _cachePos; //position at the start of the cache
        uint32 _cacheSize;//current size of the cache
        uint32 _cacheMax; //maximum size of the cache bugger
        int8   _cacheOwner; //set to 1 if the chunk is cache owner
        CachedFileChunk* _parent;
protected:
        CachedFileChunk(CachedFileChunk *);

public:
        CachedFileChunk(const char *fname);
        virtual ~CachedFileChunk();
        Chunk *subBlock();
        bool read(void *buffer, uint32 size);
        int8 getChar();
        byte getByte();
        short getShort();
        uint16 getWord();
        uint32 getDword();
        void reinit(uint32 offset);
        void setCache(unsigned char* cache, int32 cachePos, int32 cacheSize, int32 cacheMax);
        void fillCache();
};


chunk.cpp
----------------------------------------------------------
#define DW_LE_BE(x) (((x)&0xFF)<<24) + (((x)&0xFF00) <<8) + (((x)&0xFF0000) >> 8) +(((x)&0xFF000000)>>24)

CachedFileChunk::CachedFileChunk(CachedFileChunk * parent) {
        _data = NULL;
        _cacheOwner = 0;
        _parent = parent;
}

CachedFileChunk::CachedFileChunk(const char *fname) {
        _data = new ScummFile();
        if (!g_scumm->openFile(*_data, fname))
                error("FileChunk: Unable to open file %s", fname);

        _type = _data->readUint32BE();
        _size = _data->readUint32BE();
        _offset = sizeof(Chunk::type) + sizeof(uint32);
        _curPos = 0;

        _cacheOwner = 1;
        _cachePos  =  0;
        _cacheMax =  64 * 1024;
        _cache = (unsigned char*) malloc(_cacheMax);

        if (_cache == NULL) {
                error("cache malloc failed! ");
        } 
        memset(_cache, 0, _cacheMax);

        _data->seek(0);
        _cacheSize = _data->read(_cache, _cacheMax);
        _parent = NULL;
}

CachedFileChunk::~CachedFileChunk() {
        if (_data)
                _data->decRef();

        if (_parent != NULL) {
                _parent->setCache(_cache, _cachePos, _cacheSize, _cacheMax);
        }
        if (_cacheOwner && _cache) {
                free(_cache);
        }
}

void CachedFileChunk::setCache(unsigned char* cache, int32 cachePos, int32 cacheSize, int32 cacheMax) {
        _cache = cache;
        _cachePos = cachePos;
        _cacheSize = cacheSize;
        _cacheMax = cacheMax;
}


Chunk *CachedFileChunk::subBlock() {
        int dword;
        CachedFileChunk *ptr = new CachedFileChunk(this);
        ptr->setCache(_cache, _cachePos, _cacheSize, _cacheMax);

        ptr->_data = _data;
        _data->incRef();

        
        dword = getDword();
        ptr->_type = DW_LE_BE(dword);
        dword = getDword();
        ptr->_size = DW_LE_BE(dword);
        _curPos -= 8;

        ptr->_offset = _offset + _curPos + sizeof(Chunk::type) + sizeof(uint32) ;
        ptr->_curPos = 0;

        //seek behind the sub block
        seek(sizeof(Chunk::type) + sizeof(uint32) + ptr->getSize()); 
        return ptr;
}
void CachedFileChunk::fillCache() {
        int position;
        int cachePoint;
        int cacheHalf;
        int size;

        //cache reached end of file
        if (_cacheSize < _cacheMax) {
                return;
        }

        cacheHalf = _cacheMax / 2;
        position = _offset + _curPos;
        cachePoint = _cachePos + cacheHalf;

        //current position is beyond the half of the cache
        //i.e. cache holds a lot of old data
        if (position > cachePoint) {
                //copy 2nd half of the cache to 1st half of the cache
                memcpy(_cache, _cache + cacheHalf, cacheHalf);
                //read the rest of the cache
                size = _data->read(_cache+cacheHalf, cacheHalf);
                _cacheSize = cacheHalf + size;
                _cachePos += cacheHalf;
        }
}

bool CachedFileChunk::read(void *buffer, uint32 size) {
        int theSize;
        int position;
        int blockSize;
        int cacheEnd;
        int bufferPos;

//      printf(" read chunk: size=%d cachePos=%d cacheSize=%d _offset=%d _curPos=%d\n", size, _cachePos, _cacheSize, _offset, _curPos);
        theSize = size;
        bufferPos = 0;
        while (theSize) {
                position = _offset + _curPos;
                blockSize = theSize;
                cacheEnd = _cachePos + _cacheSize;
                if (blockSize > cacheEnd-position) {
                        blockSize = cacheEnd - position;
                        //copy the rest of the cache into buffer
                        memcpy((char*)buffer+bufferPos, _cache + (position-_cachePos), blockSize);
                        //read new data into cache cache
                        _data->seek(position+blockSize);
                        _cacheSize = _data->read(_cache, _cacheMax);
                        _cachePos = cacheEnd;
                } else {
                        memcpy((char*)buffer+bufferPos, _cache + (position-_cachePos), blockSize);
                }
                theSize -= blockSize;
                bufferPos+= blockSize;
                _curPos +=blockSize;
        }
        return true;
}

int8 CachedFileChunk::getChar() {
        return (int8)getByte();
}

byte CachedFileChunk::getByte() {
        byte b;
        read(&b,1);
        return b;
}

int16 CachedFileChunk::getShort() {
        return (int16)getWord();
}

uint16 CachedFileChunk::getWord() {
        uint16 i;
        read(&i,2);
        return READ_LE_UINT16(&i);
}

uint32 CachedFileChunk::getDword() {
        uint32 i;
        read(&i,4);
        return READ_LE_UINT32(&i);
}

void CachedFileChunk::reinit(uint32 offset) {
        _offset = 0;
        _data->seek(0);
        _type = _data->readUint32BE();
        _size = _data->readUint32BE();
        _curPos = 0;

        _cachePos  =  0;
        _cacheSize = _data->read(_cache, _cacheMax);
}

smush_player.h
-----------------------------------------------------------------

The change is only the static _update needed
static bool _updateNeeded;


smush_player.cpp
-----------------------------------------------------------------
bool SmushPlayer::_updateNeeded = false;

void SmushPlayer::timerCallback(void *refCon) {
        if (!_updateNeeded) {
                ((SmushPlayer *)refCon)->parseNextFrame();
        }
}



void SmushPlayer::play(const char *filename, int32 offset, int32 startFrame) {
        uint32 diff_time, start_time;

        // Verify the specified file exists
        ScummFile f;
        _vm->openFile(f, filename);
        if (!f.isOpen()) {
                warning("SmushPlayer::play() File not found %s", filename);
                return;
        }
        f.close();

        tryOggFile(filename);

        _updateNeeded = false;
        
        // Hide mouse
        bool oldMouseState = _vm->_system->showMouse(false);

        // Load the video
        setupAnim(filename);
        init();

        if (offset) {
                _base->seek(offset - 8, FileChunk::seek_start);
                _frame = startFrame;
                _middleAudio = true;
        }

        //primary warmup of the smush file
        parseNextFrame();

        for (;;) {
                _vm->parseEvents();
                _vm->processKbd(true);

                
                if (_updateNeeded) {
                        _vm->_system->updateScreen();
                        _updateNeeded = false;

                        //debugC(DEBUG_SMUSH, "Smush stats: BackendUpdateScreen( %03d )", end_time - start_time);

                }
                start_time = _vm->_system->getMillis();
                _base->fillCache();
                diff_time =  _vm->_system->getMillis() - start_time;
                if (diff_time < 5) {
                        _vm->_system->delayMillis(10-diff_time);
                }

                if (_vm->_smushVideoShouldFinish || _vm->_quit || _vm->_saveLoadFlag)
                        break;
        };

        release();

        // Reset mouse state
        _vm->_system->showMouse(oldMouseState);
}

Also, the FileChunk class is replaced by CachedFileChunk in the:
setupAnim and seekSan methods of the SmushPlayer.