thirdparty/scummvm
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

some cleanup

Browse source 
svn-id: r4870
This commit is contained in:
Paweł Kołodziejski 2002-08-30 07:24:45 +00:00
parent 9b34985faa
commit a1fa514b5a
26 changed files with 537 additions and 535 deletions
Download patch file Download diff file Expand all files Collapse all files

56
scumm/smush/blitter.cpp
View file

@ -27,7 +27,7 @@
#include <assert.h>
#include <string.h> // for memcpy
Blitter::Blitter(char * ptr, const Point & dstsize, const Rect & src) :
Blitter::Blitter(byte * ptr, const Point & dstsize, const Rect & src) :
_ptr(ptr),
_clip(dstsize),
_src(src),
@ -53,7 +53,7 @@ Blitter::~Blitter() {
#endif
}
void Blitter::advance(int x, int y) {
void Blitter::advance(int32 x, int32 y) {
if(y != 0) {
_cur.set(_src.left() + x, _cur.getY() + y);
} else {
@ -66,11 +66,11 @@ void Blitter::advance(int x, int y) {
_outside = ! _src.isInside(_cur);
}
void Blitter::advanceBlock(int x, int y) {
void Blitter::advanceBlock(int32 x, int32 y) {
advance(x * 4, y * 4);
}
void Blitter::put(char data) {
void Blitter::put(byte data) {
if(!_outside) {
*_offset = data;
advance();
@ -80,7 +80,7 @@ void Blitter::put(char data) {
#endif
}
void Blitter::put(char data, unsigned int len) {
void Blitter::put(byte data, uint32 len) {
while(len) {
if(_outside) {
#ifdef DEBUG_CLIPPER
@ -88,14 +88,14 @@ void Blitter::put(char data, unsigned int len) {
#endif
break;
}
int l = MIN((int)len, MIN(_clip.getX() - _cur.getX(), _src.right() - _cur.getX()));
int32 l = MIN((int32)len, MIN(_clip.getX() - _cur.getX(), _src.right() - _cur.getX()));
len -= l;
memset(_offset, data, l);
advance(l);
}
}
void Blitter::blit(char * ptr, unsigned int len) {
void Blitter::blit(byte * ptr, uint32 len) {
while(len) {
if(_outside) {
#ifdef DEBUG_CLIPPER
@ -103,7 +103,7 @@ void Blitter::blit(char * ptr, unsigned int len) {
#endif
break;
}
int l = MIN((int)len, MIN(_clip.getX() - _cur.getX(), _src.right() - _cur.getX()));
int32 l = MIN((int32)len, MIN(_clip.getX() - _cur.getX(), _src.right() - _cur.getX()));
len -= l;
memcpy(_offset, ptr, l);
ptr += l;
@ -111,7 +111,7 @@ void Blitter::blit(char * ptr, unsigned int len) {
}
}
void Blitter::blit(Chunk & src, unsigned int len) {
void Blitter::blit(Chunk & src, uint32 len) {
while(len) {
if(_outside) {
#ifdef DEBUG_CLIPPER
@ -119,18 +119,18 @@ void Blitter::blit(Chunk & src, unsigned int len) {
#endif
break;
}
int l = MIN((int)len, MIN(_clip.getX() -_cur.getX(), _src.right() - _cur.getX()));
int32 l = MIN((int32)len, MIN(_clip.getX() -_cur.getX(), _src.right() - _cur.getX()));
len -= l;
src.read(_offset, l);
advance(l);
}
}
void Blitter::putBlock(unsigned int data) {
void Blitter::putBlock(uint32 data) {
if(_cur.getX() + 3 < _src.right() && _cur.getY() + 3 < _src.bottom()) { // This is clipping
assert((_clip.getX() & 3) == 0);
unsigned int * dst = (unsigned int *)_offset;
int line_size = _clip.getX() >> 2;
uint32 * dst = (uint32 *)_offset;
int32 line_size = _clip.getX() >> 2;
data = TO_LE_32(data);
*dst = data; dst += line_size;
@ -146,11 +146,11 @@ void Blitter::putBlock(unsigned int data) {
advanceBlock();
}
void Blitter::putBlock(unsigned int d1, unsigned int d2, unsigned int d3, unsigned int d4) {
void Blitter::putBlock(uint32 d1, uint32 d2, uint32 d3, uint32 d4) {
if(_cur.getX() + 3 < _src.right() && _cur.getY() + 3 < _src.bottom()) { // This is clipping
assert((_clip.getX() & 3) == 0);
unsigned int * dst = (unsigned int *)_offset;
int line_size = _clip.getX() >> 2;
uint32 * dst = (uint32 *)_offset;
int32 line_size = _clip.getX() >> 2;
*dst = TO_LE_32(d4); dst += line_size;
*dst = TO_LE_32(d3); dst += line_size;
@ -165,12 +165,12 @@ void Blitter::putBlock(unsigned int d1, unsigned int d2, unsigned int d3, unsign
advanceBlock();
}
void Blitter::putBlock(unsigned char * data) {
void Blitter::putBlock(byte * data) {
if(_cur.getX() + 3 < _src.right() && _cur.getY() + 3 < _src.bottom()) { // This is clipping
assert((_clip.getX() & 3) == 0);
unsigned int * dst = (unsigned int *)_offset;
int line_size = _clip.getX() >> 2;
unsigned int * src = (unsigned int *)data;
uint32 * dst = (uint32 *)_offset;
int32 line_size = _clip.getX() >> 2;
uint32 * src = (uint32 *)data;
*dst = TO_LE_32(*src++); dst += line_size;
*dst = TO_LE_32(*src++); dst += line_size;
*dst = TO_LE_32(*src++); dst += line_size;
@ -186,8 +186,8 @@ void Blitter::putBlock(unsigned char * data) {
void Blitter::putBlock(Chunk & src) {
if(_cur.getX() + 3 < _src.right() && _cur.getY() + 3 < _src.bottom()) { // This is clipping
assert((_clip.getX() & 3) == 0);
unsigned int * dst = (unsigned int *)_offset;
int line_size = _clip.getX() >> 2;
uint32 * dst = (uint32 *)_offset;
int32 line_size = _clip.getX() >> 2;
*dst = TO_LE_32(src.getDword()); dst += line_size;
*dst = TO_LE_32(src.getDword()); dst += line_size;
*dst = TO_LE_32(src.getDword()); dst += line_size;
@ -200,16 +200,16 @@ void Blitter::putBlock(Chunk & src) {
advanceBlock();
}
void Blitter::blockCopy(int offset) {
void Blitter::blockCopy(int32 offset) {
if(_cur.getX() + 3 < _src.right() && _cur.getY() + 3 < _src.bottom()) {// This is clipping
char * dst = _offset;
*((unsigned int *)dst) = *((unsigned int *)(dst + offset));
byte * dst = _offset;
*((uint32 *)dst) = *((uint32 *)(dst + offset));
dst += _clip.getX();
*((unsigned int *)dst) = *((unsigned int *)(dst + offset));
*((uint32 *)dst) = *((uint32 *)(dst + offset));
dst += _clip.getX();
*((unsigned int *)dst) = *((unsigned int *)(dst + offset));
*((uint32 *)dst) = *((uint32 *)(dst + offset));
dst += _clip.getX();
*((unsigned int *)dst) = *((unsigned int *)(dst + offset));
*((uint32 *)dst) = *((uint32 *)(dst + offset));
#ifdef DEBUG_CLIPPER
} else {
_clippedBlock ++;

32
scumm/smush/blitter.h
View file

@ -1,4 +1,4 @@
/* ScummVM - Scumm Interpreter
/* ScummVM - Scumm int32erpreter
* Copyright (C) 2001/2002 The ScummVM project
*
* This program is free software; you can redistribute it and/or
@ -44,15 +44,15 @@ class Chunk;
*/
class Blitter {
private:
char * _ptr; //!< This is the pointer to the start of the frame buffer
char * _offset; //!< This is the current pointer in the frame buffer
byte * _ptr; //!< This is the pointer to the start of the frame buffer
byte * _offset; //!< This is the current pointer in the frame buffer
Point _clip; //!< This is the size of the frame buffer (width/height)
Rect _src; //!< This is the size and position of the destination rectangle
Point _cur; //!< This is the current position in the destination rectangle
bool _outside; //!< flag that is set to \c true when the blitter reach the end of the destination rectangle
#ifdef DEBUG_CLIPPER
int _clipped;
int _clippedBlock;
int32 _clipped;
int32 _clippedBlock;
#endif
public:
/*! @brief constructor
@ -61,19 +61,19 @@ public:
@param dstsize the size of the frame buffer
@param src the rectangle to blit to
*/
Blitter(char * buffer, const Point & dstsize, const Rect & src);
Blitter(byte * buffer, const Point & dstsize, const Rect & src);
virtual ~Blitter();
void blit(char *, unsigned int); //!< This method allows to blit directly some data from a buffer
void blit(Chunk &, unsigned int); //!< This method allows to blit directly some data from a Chunk
void put(char); //!< This method allows to blit one byte
void put(char, unsigned int); //!< This method allows to blit one byte several times
void advance(int = 1, int = 0); //!< This method allows to advance the current position in the blitter
void advanceBlock(int = 1, int = 0); //!< This method allows to advance the current position in the blitter in terms of blocks
void putBlock(unsigned int); //!< This method allows to blit one block from an int value repeated 4 time
void blit(byte *, uint32); //!< This method allows to blit directly some data from a buffer
void blit(Chunk &, uint32); //!< This method allows to blit directly some data from a Chunk
void put(byte); //!< This method allows to blit one byte
void put(byte, uint32); //!< This method allows to blit one byte several times
void advance(int32 = 1, int32 = 0); //!< This method allows to advance the current position in the blitter
void advanceBlock(int32 = 1, int32 = 0); //!< This method allows to advance the current position in the blitter in terms of blocks
void putBlock(uint32); //!< This method allows to blit one block from an int32 value repeated 4 time
void putBlock(Chunk &); //!< This method allows to blit one block directly read from a Chunk
void putBlock(unsigned char *); //!< This method allows to blit one block directly from a buffer
void putBlock(unsigned int, unsigned int, unsigned int, unsigned int); //!< This method allows to blit one block from a 4 int value
void blockCopy(int); //!< This method allows to copy one block from another separated by the given offset
void putBlock(byte *); //!< This method allows to blit one block directly from a buffer
void putBlock(uint32, uint32, uint32, uint32); //!< This method allows to blit one block from a 4 int32 value
void blockCopy(int32); //!< This method allows to copy one block from another separated by the given offset
};
#endif

2
scumm/smush/brenderer.cpp
View file

@ -54,7 +54,7 @@ bool BaseRenderer::initFrame(const Point & p) {
return true;
}
char * BaseRenderer::lockFrame(int frame) {
char * BaseRenderer::lockFrame(int32 frame) {
_frame = frame;
if(!_data) error("no allocated image buffer in lock_frame");
return _data;

30
scumm/smush/brenderer.h
View file

@ -1,4 +1,4 @@
/* ScummVM - Scumm Interpreter
/* ScummVM - Scumm int32erpreter
* Copyright (C) 2001/2002 The ScummVM project
*
* This program is free software; you can redistribute it and/or
@ -36,34 +36,34 @@ class BaseRenderer : public Renderer {
private:
Palette _pal; //!< The current palette
char * _data; //!< The current frame buffer
int _frame; //!< The current frame number
int _nbframes; //!< The number of frames in the animation
int _width; //!< The current frame's width
int _height; //!< The current frame's height
int32 _frame; //!< The current frame number
int32 _nbframes; //!< The number of frames in the animation
int32 _width; //!< The current frame's width
int32 _height; //!< The current frame's height
const char * _fname; //!< The filename of the animation being played
protected:
virtual void save(int frame = -1) = 0;
virtual void save(int32 frame = -1) = 0;
protected:
const char * getFilename() const { return _fname; }; //!< accessor for animation filename
int getNbframes() const { return _nbframes; }; //!< accessor for number of frames
int getWidth() const { return _width; }; //!< accessor for current width
int getHeight() const { return _height; }; //!< accessor for current height
int32 getNbframes() const { return _nbframes; }; //!< accessor for number of frames
int32 getWidth() const { return _width; }; //!< accessor for current width
int32 getHeight() const { return _height; }; //!< accessor for current height
const Palette & pal() const { return _pal; }; //!< accessor for current palette
const char * data() const { return _data; }; //!< accessor for current frame buffer
void clean(); //!< memory cleanup (deletes frame buffer)
void setFrame(int f) { _frame = f; }; //!< allows to change the frame number
void setFrame(int32 f) { _frame = f; }; //!< allows to change the frame number
public:
int getFrame() const { return _frame; }; //!< accessor for current frame number
int32 getFrame() const { return _frame; }; //!< accessor for current frame number
BaseRenderer();
virtual ~BaseRenderer();
virtual bool initFrame(const Point & size);
virtual char * lockFrame(int frame);
virtual char * lockFrame(int32 frame);
virtual bool unlockFrame();
virtual bool flipFrame();
virtual bool setPalette(const Palette & pal);
virtual bool startDecode(const char * fname, int version, int nbframes) { _fname = fname; _nbframes = nbframes; return true; }
virtual bool startDecode(const char * fname, int32 version, int32 nbframes) { _fname = fname; _nbframes = nbframes; return true; }
virtual Mixer * getMixer() { return 0; };
virtual bool prematureClose() { return false; };
};
@ -75,11 +75,11 @@ public:
*/
class NullRenderer : public BaseRenderer {
protected:
void save(int frame = -1) {};
void save(int32 frame = -1) {};
public:
NullRenderer() {};
virtual ~NullRenderer() {};
bool wait(int ms) { return true; };
bool wait(int32 ms) { return true; };
};
#endif

112
scumm/smush/channel.h
View file

@ -1,4 +1,4 @@
/* ScummVM - Scumm Interpreter
/* ScummVM - Scumm int32erpreter
* Copyright (C) 2001/2002 The ScummVM project
*
* This program is free software; you can redistribute it and/or
@ -37,69 +37,69 @@
class Chunk;
class ContChunk;
/*! @brief interface for a sound channel (a track)
/*! @brief int32erface for a sound channel (a track)
This is the interface for sound channels.
This is the int32erface for sound channels.
*/
class _Channel {
public:
virtual ~_Channel() {};
// called by the smush_player
virtual bool appendData(Chunk & b, int size) = 0;
virtual bool setParameters(int, int, int, int) = 0;
virtual bool checkParameters(int, int, int, int, int) = 0;
virtual bool appendData(Chunk & b, int32 size) = 0;
virtual bool setParameters(int32, int32, int32, int32) = 0;
virtual bool checkParameters(int32, int32, int32, int32, int32) = 0;
// called by the mixer
virtual bool isTerminated() const = 0;
virtual int availableSoundData() const = 0;
virtual void getSoundData(short * sound_buffer, int size) = 0; // size is in sample
virtual void getSoundData(char * sound_buffer, int size) = 0;
virtual bool getParameters(int &rate, bool &stereo, bool &is_16bit) = 0;
virtual int getTrackIdentifier() const = 0;
virtual int32 availableSoundData() const = 0;
virtual void getSoundData(int16 * sound_buffer, int32 size) = 0; // size is in sample
virtual void getSoundData(int8 * sound_buffer, int32 size) = 0;
virtual bool getParameters(int32 &rate, bool &stereo, bool &is_16bit) = 0;
virtual int32 getTrackIdentifier() const = 0;
};
class SaudChannel : public _Channel {
private:
int _track; //!< The track identifier
int _nbframes; //!< number of frames of the track (unused)
int _dataSize; //!< the size of the sound buffer
int _frequency; //!< the frequency target of the track (always 22050)
int32 _track; //!< The track identifier
int32 _nbframes; //!< number of frames of the track (unused)
int32 _dataSize; //!< the size of the sound buffer
int32 _frequency; //!< the frequency target of the track (always 22050)
bool _inData; //!< are we processing data ?
bool _markReached; //!< set to \c true when the SMRK tag is reached
int _flags; //!< current flags of the track (unused)
int _volume; //!< the current track volume
int _balance; //!< the current track balance
int _index; //!< the current PSAD index (for coherency checking)
short _voltable[2][256]; //!< the precalculated volume table (stereo 16 bits)
unsigned char * _tbuffer; //!< data temporary buffer
int _tbufferSize; //!< temporary buffer size
unsigned char * _sbuffer; //!< sound buffer
int _sbufferSize; //!< sound buffer size
int32 _flags; //!< current flags of the track (unused)
int32 _volume; //!< the current track volume
int32 _balance; //!< the current track balance
int32 _index; //!< the current PSAD index (for coherency checking)
int16 _voltable[2][256]; //!< the precalculated volume table (stereo 16 bits)
byte * _tbuffer; //!< data temporary buffer
int32 _tbufferSize; //!< temporary buffer size
byte * _sbuffer; //!< sound buffer
int32 _sbufferSize; //!< sound buffer size
protected:
void handleStrk(Chunk & c);
void handleSmrk(Chunk & c);
void handleShdr(Chunk & c);
bool handleSubTags(int & offset);
bool handleSubTags(int32 & offset);
bool processBuffer();
void recalcVolumeTable();
public:
SaudChannel(int track, int freq);
SaudChannel(int32 track, int32 freq);
virtual ~SaudChannel();
bool isTerminated() const;
bool setParameters(int duration, int flags, int vol1, int vol2);
bool checkParameters(int index, int duration, int flags, int vol1, int vol2);
bool appendData(Chunk & b, int size);
int availableSoundData() const;
void getSoundData(short * sound_buffer, int size);
void getSoundData(char * sound_buffer, int size) { error("16bit request for SAUD channel should never happen"); };
bool getParameters(int &rate, bool &stereo, bool &is_16bit) {
bool setParameters(int32 duration, int32 flags, int32 vol1, int32 vol2);
bool checkParameters(int32 index, int32 duration, int32 flags, int32 vol1, int32 vol2);
bool appendData(Chunk & b, int32 size);
int32 availableSoundData() const;
void getSoundData(int16 * sound_buffer, int32 size);
void getSoundData(int8 * sound_buffer, int32 size) { error("16bit request for SAUD channel should never happen"); };
bool getParameters(int32 &rate, bool &stereo, bool &is_16bit) {
rate = _frequency;
stereo = true;
is_16bit = true;
return true;
};
virtual int getTrackIdentifier() const { return _track; };
virtual int32 getTrackIdentifier() const { return _track; };
};
/*! @brief class for a IACT sound ::channel (a The Dig track)
@ -110,22 +110,22 @@ public:
*/
class ImuseChannel : public _Channel {
private:
int _track; //!< the track number
unsigned char * _tbuffer; //!< data temporary buffer
int _tbufferSize; //!< temporary buffer size
unsigned char * _sbuffer; //!< sound buffer
int _sbufferSize; //!< sound buffer size
int _srbufferSize;
int _frequency; //!< the target frequency of the ::mixer
int _dataSize; //!< remaining size of sound data in the iMUS buffer
int32 _track; //!< the track number
byte * _tbuffer; //!< data temporary buffer
int32 _tbufferSize; //!< temporary buffer size
byte * _sbuffer; //!< sound buffer
int32 _sbufferSize; //!< sound buffer size
int32 _srbufferSize;
int32 _frequency; //!< the target frequency of the ::mixer
int32 _dataSize; //!< remaining size of sound data in the iMUS buffer
bool _inData;
int _bitsize; //!< the bitsize of the original data
int _rate; //!< the sampling rate of the original data
int _channels; //!< the number of channels of the original data
int32 _bitsize; //!< the bitsize of the original data
int32 _rate; //!< the sampling rate of the original data
int32 _channels; //!< the number of channels of the original data
protected:
int decode(int size, int &ret);
int32 decode(int32 size, int32 &ret);
void decode();
bool processBuffer();
bool handleMap(Chunk &);
@ -133,25 +133,25 @@ protected:
bool handleText(Chunk &);
bool handleRegion(Chunk &);
bool handleStop(Chunk &);
bool handleSubTags(int & offset);
bool handleSubTags(int32 & offset);
public:
ImuseChannel(int track, int freq);
ImuseChannel(int32 track, int32 freq);
virtual ~ImuseChannel();
bool isTerminated() const;
bool setParameters(int nbframes, int size, int unk1, int unk2);
bool checkParameters(int index, int nbframes, int size, int unk1, int unk2);
bool appendData(Chunk & b, int size);
int availableSoundData() const;
void getSoundData(short * sound_buffer, int size);
void getSoundData(char * sound_buffer, int size);
bool getParameters(int &rate, bool &stereo, bool &is_16bit) {
bool setParameters(int32 nbframes, int32 size, int32 unk1, int32 unk2);
bool checkParameters(int32 index, int32 nbframes, int32 size, int32 unk1, int32 unk2);
bool appendData(Chunk & b, int32 size);
int32 availableSoundData() const;
void getSoundData(int16 * sound_buffer, int32 size);
void getSoundData(int8 * sound_buffer, int32 size);
bool getParameters(int32 &rate, bool &stereo, bool &is_16bit) {
rate = _frequency;
stereo = (_channels == 2);
is_16bit = (_bitsize > 8);
return true;
};
virtual int getTrackIdentifier() const { return _track; };
virtual int32 getTrackIdentifier() const { return _track; };
};
#endif

84
scumm/smush/chunk.cpp
View file

@ -1,4 +1,4 @@
/* ScummVM - Scumm Interpreter
/* ScummVM - Scumm int32erpreter
* Copyright (C) 2001/2002 The ScummVM project
*
* This program is free software; you can redistribute it and/or
@ -32,8 +32,8 @@
class FilePtr {
char * _filename;
FILE * _ifs;
int _refcount;
int _curPos;
int32 _refcount;
int32 _curPos;
public:
FilePtr(const char * fname) : _refcount(1), _curPos(0) {
debug(9, "FilePtr created for %s", fname);
@ -46,17 +46,17 @@ public:
free(_filename);
fclose(_ifs);
}
int tell() {
int32 tell() {
return _curPos;
}
bool seek(int pos) {
bool seek(int32 pos) {
if(pos != _curPos) {
fseek(_ifs, pos, SEEK_SET);
_curPos = pos;
}
return true;
}
bool read(void * ptr, int size) {
bool read(void * ptr, int32 size) {
fread(ptr, size, 1, _ifs);
_curPos += size;
return true;
@ -101,7 +101,7 @@ Chunk::type FileChunk::getType() const {
return _type;
}
unsigned int FileChunk::getSize() const {
uint32 FileChunk::getSize() const {
return _size;
}
@ -110,7 +110,7 @@ Chunk * FileChunk::subBlock() {
ptr->_data = _data;
_data->incRef();
_data->seek(_offset + _curPos);
unsigned int temp;
uint32 temp;
_data->read(&temp, 4);
ptr->_type = TO_BE_32(temp);
_data->read(&temp, 4);
@ -125,22 +125,22 @@ bool FileChunk::eof() const {
return _curPos >= _size;
}
unsigned int FileChunk::tell() const {
uint32 FileChunk::tell() const {
return _curPos;
}
bool FileChunk::seek(int delta, seek_type dir) {
bool FileChunk::seek(int32 delta, seek_type dir) {
switch(dir) {
case seek_cur:
_curPos += delta;
break;
case seek_start:
if(delta < 0) error("invalid seek request");
_curPos = (unsigned int)delta;
_curPos = (uint32)delta;
break;
case seek_end:
if(delta > 0 || (_size + delta) < 0) error("invalid seek request");
_curPos = (unsigned int)(_size + delta);
_curPos = (uint32)(_size + delta);
break;
}
if(_curPos > _size) {
@ -149,7 +149,7 @@ bool FileChunk::seek(int delta, seek_type dir) {
return true;
}
bool FileChunk::read(void * buffer, unsigned int size) {
bool FileChunk::read(void * buffer, uint32 size) {
if(size <= 0 || (_curPos + size) > _size) error("invalid buffer read request");
_data->seek(_offset + _curPos);
_data->read(buffer, size);
@ -166,43 +166,43 @@ int8 FileChunk::getChar() {
return buffer;
}
unsigned char FileChunk::getByte() {
byte FileChunk::getByte() {
if(_curPos >= _size) error("invalid byte read request");
_data->seek(_offset + _curPos);
unsigned char buffer;
byte buffer;
_data->read(&buffer, sizeof(buffer));
_curPos+= sizeof(buffer);
return buffer;
}
short FileChunk::getShort() {
unsigned short buffer = getWord();
return *((short*)&buffer);
int16 FileChunk::getShort() {
int16 buffer = getWord();
return *((int16*)&buffer);
}
unsigned short FileChunk::getWord() {
uint16 FileChunk::getWord() {
if(_curPos >= _size - 1) error("invalid word read request");
_data->seek(_offset + _curPos);
unsigned short buffer;
uint16 buffer;
_data->read(&buffer, sizeof(buffer));
_curPos+= sizeof(buffer);
return TO_LE_16(buffer);
}
unsigned int FileChunk::getDword() {
uint32 FileChunk::getDword() {
if(_curPos >= _size - 3) error("invalid dword read request");
_data->seek(_offset + _curPos);
unsigned int buffer;
uint32 buffer;
_data->read(&buffer, sizeof(buffer));
_curPos+= sizeof(buffer);
return TO_LE_32(buffer);
}
ContChunk::ContChunk(char * data) {
if(data == 0) error("Chunk() called with NULL pointer");
ContChunk::ContChunk(byte * data) {
if(data == 0) error("Chunk() called with NULL point32er");
_type = (Chunk::type)READ_BE_UINT32(data);
_size = READ_BE_UINT32(data + 4);
_data = data + sizeof(Chunk::type) + sizeof(unsigned int);
_data = data + sizeof(Chunk::type) + sizeof(uint32);
_curPos = 0;
}
@ -210,13 +210,13 @@ Chunk::type ContChunk::getType() const {
return _type;
}
unsigned int ContChunk::getSize() const {
uint32 ContChunk::getSize() const {
return _size;
}
Chunk * ContChunk::subBlock() {
ContChunk * ptr = new ContChunk(_data + _curPos);
seek(sizeof(Chunk::type) + sizeof(unsigned int) + ptr->getSize());
seek(sizeof(Chunk::type) + sizeof(uint32) + ptr->getSize());
return ptr;
}
@ -224,22 +224,22 @@ bool ContChunk::eof() const {
return _curPos >= _size;
}
unsigned int ContChunk::tell() const {
uint32 ContChunk::tell() const {
return _curPos;
}
bool ContChunk::seek(int delta, seek_type dir) {
bool ContChunk::seek(int32 delta, seek_type dir) {
switch(dir) {
case seek_cur:
_curPos += delta;
break;
case seek_start:
if(delta < 0) error("invalid seek request");
_curPos = (unsigned int)delta;
_curPos = (uint32)delta;
break;
case seek_end:
if(delta > 0 || (_size + delta) < 0) error("invalid seek request");
_curPos = (unsigned int)(_size + delta);
_curPos = (uint32)(_size + delta);
break;
}
if(_curPos > _size) {
@ -248,7 +248,7 @@ bool ContChunk::seek(int delta, seek_type dir) {
return true;
}
bool ContChunk::read(void * buffer, unsigned int size) {
bool ContChunk::read(void * buffer, uint32 size) {
if(size <= 0 || (_curPos + size) > _size) error("invalid buffer read request");
memcpy(buffer, _data + _curPos, size);
_curPos += size;
@ -260,29 +260,29 @@ int8 ContChunk::getChar() {
return _data[_curPos++];
}
unsigned char ContChunk::getByte() {
byte ContChunk::getByte() {
if(_curPos >= _size) error("invalid byte read request");
unsigned char * ptr = (unsigned char *)(_data + _curPos);
byte * ptr = (byte *)(_data + _curPos);
_curPos += 1;
return *ptr;
}
short ContChunk::getShort() {
if(_curPos >= _size - 1) error("invalid short read request");
unsigned short buffer = getWord();
return *((short*)&buffer);
int16 ContChunk::getShort() {
if(_curPos >= _size - 1) error("invalid int16 read request");
int16 buffer = getWord();
return *((int16*)&buffer);
}
unsigned short ContChunk::getWord() {
uint16 ContChunk::getWord() {
if(_curPos >= _size - 1) error("invalid word read request");
unsigned short * ptr = (unsigned short *)(_data + _curPos);
uint16 * ptr = (uint16 *)(_data + _curPos);
_curPos += 2;
return READ_LE_UINT16(ptr);
}
unsigned int ContChunk::getDword() {
uint32 ContChunk::getDword() {
if(_curPos >= _size - 3) error("invalid dword read request");
unsigned int * ptr = (unsigned int *)(_data + _curPos);
uint32 * ptr = (uint32 *)(_data + _curPos);
_curPos += 4;
return READ_LE_UINT32(ptr);
}

62
scumm/smush/chunk.h
View file

@ -34,7 +34,7 @@ class Chunk {
public:
enum seek_type { seek_start, seek_end, seek_cur };
virtual ~Chunk() {};
typedef unsigned int type; //!< type of a Chunk (i.e. The first 4byte field of the Chunk structure).
typedef uint32 type; //!< type of a Chunk (i.e. The first 4byte field of the Chunk structure).
/*! @brief convert a type to a string
Utility function that convert a type to a string.
@ -46,17 +46,17 @@ public:
static const char * ChunkString(type t);
virtual type getType() const = 0; //!< return the type of the Chunk
virtual unsigned int getSize() const = 0; //!< return the size of the Chunk
virtual uint32 getSize() const = 0; //!< return the size of the Chunk
virtual Chunk * subBlock() = 0; //!< extract a subChunk from the current read position
virtual bool eof() const = 0; //!< is the Chunk completely read ?
virtual unsigned int tell() const = 0; //!< get the Chunk current read position
virtual bool seek(int delta, seek_type dir = seek_cur) = 0; //!< move the current read position inside the Chunk
virtual bool read(void * buffer, unsigned int size) = 0; //!< read some data for the current read position
virtual uint32 tell() const = 0; //!< get the Chunk current read position
virtual bool seek(int32 delta, seek_type dir = seek_cur) = 0; //!< move the current read position inside the Chunk
virtual bool read(void * buffer, uint32 size) = 0; //!< read some data for the current read position
virtual int8 getChar() = 0; //!< extract the character at the current read position
virtual unsigned char getByte() = 0; //!< extract the byte at the current read position
virtual short getShort() = 0; //!< extract the short at the current read position
virtual unsigned short getWord() = 0; //!< extract the word at the current read position
virtual unsigned int getDword()= 0; //!< extract the dword at the current read position
virtual byte getByte() = 0; //!< extract the byte at the current read position
virtual int16 getShort() = 0; //!< extract the short at the current read position
virtual uint16 getWord() = 0; //!< extract the word at the current read position
virtual uint32 getDword()= 0; //!< extract the dword at the current read position
};
class FilePtr;
@ -70,26 +70,26 @@ class FileChunk : public Chunk {
private:
FilePtr * _data;
type _type;
unsigned int _size;
unsigned int _offset;
unsigned int _curPos;
uint32 _size;
uint32 _offset;
uint32 _curPos;
protected:
FileChunk();
public:
FileChunk(const char * fname);
virtual ~FileChunk();
type getType() const;
unsigned int getSize() const;
uint32 getSize() const;
Chunk * subBlock();
bool eof() const;
unsigned int tell() const;
bool seek(int delta, seek_type dir = seek_cur);
bool read(void * buffer, unsigned int size);
uint32 tell() const;
bool seek(int32 delta, seek_type dir = seek_cur);
bool read(void * buffer, uint32 size);
int8 getChar();
unsigned char getByte();
byte getByte();
short getShort();
unsigned short getWord();
unsigned int getDword();
uint16 getWord();
uint32 getDword();
};
/*! @brief memory based ::Chunk
@ -98,24 +98,24 @@ public:
*/
class ContChunk : public Chunk {
private:
char * _data;
byte * _data;
Chunk::type _type;
unsigned int _size;
unsigned int _curPos;
uint32 _size;
uint32 _curPos;
public:
ContChunk(char * data);
ContChunk(byte * data);
Chunk::type getType() const;
unsigned int getSize() const;
uint32 getSize() const;
Chunk * subBlock();
bool eof() const;
unsigned int tell() const;
bool seek(int delta, seek_type dir = seek_cur);
bool read(void * buffer, unsigned int size);
uint32 tell() const;
bool seek(int32 delta, seek_type dir = seek_cur);
bool read(void * buffer, uint32 size);
int8 getChar();
unsigned char getByte();
short getShort();
unsigned short getWord();
unsigned int getDword();
byte getByte();
int16 getShort();
uint16 getWord();
uint32 getDword();
};
#endif

19
scumm/smush/codec1.cpp
View file

@ -28,10 +28,10 @@ Codec1Decoder::~Codec1Decoder() {
}
bool Codec1Decoder::decode(Blitter & dst, Chunk & src) {
int val;
int size_line;
int code, length;
int h, height = getRect().height();
byte val;
int32 size_line;
int32 code, length;
int32 h, height = getRect().height();
for(h = 0; h < height; h++) {
size_line = src.getWord(); // size of compressed line !
@ -48,8 +48,10 @@ bool Codec1Decoder::decode(Blitter & dst, Chunk & src) {
if(code & 1) {
val = src.getByte();
size_line --;
if(val) dst.put(val, length);
else dst.advance(length);
if(val)
dst.put(val, length);
else
dst.advance(length);
#ifdef DEBUG_CODEC1
debug(7, "codec1 : blitting %d times %d", length, val);
#endif
@ -60,7 +62,8 @@ bool Codec1Decoder::decode(Blitter & dst, Chunk & src) {
#endif
while(length--) {
val = src.getByte();
if(val) dst.put(val);
if(val)
dst.put(val);
else dst.advance();
}
}
@ -68,7 +71,7 @@ bool Codec1Decoder::decode(Blitter & dst, Chunk & src) {
}
#ifdef DEBUG_CODEC1
if(!src.eof()) {
int len = src.getSize() - src.tell();
int32 len = src.getSize() - src.tell();
debug(7, "codec1: remaining length after decode == %d", len);
}
#endif

88
scumm/smush/codec37.cpp
View file

@ -25,7 +25,7 @@
#include "blitter.h"
#include <assert.h>
#include <string.h> // for memset
#include <string.h>
bool Codec37Decoder::initSize(const Point & p, const Rect & r) {
if(r.width() != getRect().width() && r.height() != getRect().height()) {
@ -37,13 +37,13 @@ bool Codec37Decoder::initSize(const Point & p, const Rect & r) {
return false;
Decoder::initSize(p, r);
clean();
int frame_size = getRect().width() * getRect().height();
int32 frame_size = getRect().width() * getRect().height();
_deltaSize = frame_size * 2 + DELTA_ADD * 4;
_deltaBuf = new unsigned char[_deltaSize];
_deltaBuf = new byte[_deltaSize];
if(_deltaBuf == 0) error("unable to allocate decoder buffer");
_deltaBufs[0] = _deltaBuf + DELTA_ADD;
_deltaBufs[1] = _deltaBuf + frame_size + DELTA_ADD * 3;
_offsetTable = new short[255];
_offsetTable = new int16[255];
if(_offsetTable == 0) error("unable to allocate decoder offset table");
_tableLastPitch = -1;
_tableLastIndex = -1;
@ -84,8 +84,8 @@ Codec37Decoder::~Codec37Decoder() {
clean();
}
void Codec37Decoder::maketable(int pitch, int index) {
static const signed char maketable_bytes[] = {
void Codec37Decoder::maketable(int32 pitch, int32 index) {
static const int8 maketable_bytes[] = {
0, 0, 1, 0, 2, 0, 3, 0, 5, 0, 8, 0, 13, 0, 21, 0,
-1, 0, -2, 0, -3, 0, -5, 0, -8, 0, -13, 0, -17, 0, -21, 0,
0, 1, 1, 1, 2, 1, 3, 1, 5, 1, 8, 1, 13, 1, 21, 1,
@ -192,22 +192,22 @@ void Codec37Decoder::maketable(int pitch, int index) {
_tableLastPitch = pitch;
_tableLastIndex = index;
index *= 255;
assert(index + 254 < (int)(sizeof(maketable_bytes) / 2));
assert(index + 254 < (int32)(sizeof(maketable_bytes) / 2));
for (int i = 0; i < 255; i++) {
int j = (i + index) << 1; // * 2
for (int32 i = 0; i < 255; i++) {
int32 j = (i + index) << 1; // * 2
_offsetTable[i] = maketable_bytes[j + 1] * pitch + maketable_bytes[j];
}
}
void Codec37Decoder::proc1(Blitter & dst, Chunk & src, int next_offs, int bw, int bh, int size) {
unsigned char * decoded = new unsigned char[size];
int w = 0;
void Codec37Decoder::proc1(Blitter & dst, Chunk & src, int32 next_offs, int32 bw, int32 bh, int32 size) {
byte * decoded = new byte[size];
int32 w = 0;
while(!src.eof()) {
int code = src.getByte();
int length = (code >> 1) + 1;
int32 code = src.getByte();
int32 length = (code >> 1) + 1;
if (code & 1) {
unsigned char val = src.getByte();
byte val = src.getByte();
while(length--)
decoded[w++] = val;
} else {
@ -219,7 +219,7 @@ void Codec37Decoder::proc1(Blitter & dst, Chunk & src, int next_offs, int bw, in
assert(w == size);
w = 0;
// Now we have our stream ready...
for(int i = 0; i < size; i++) {
for(int32 i = 0; i < size; i++) {
if(decoded[i] == 0xFF) {
dst.putBlock(decoded + i + 1);
i += 16;
@ -234,14 +234,14 @@ void Codec37Decoder::proc1(Blitter & dst, Chunk & src, int next_offs, int bw, in
delete []decoded;
}
void Codec37Decoder::proc2(Blitter & dst, Chunk & src, int size) { // This is codec1 like...
void Codec37Decoder::proc2(Blitter & dst, Chunk & src, int32 size) { // This is codec1 like...
#ifdef DEBUG_CODEC37_PROC2
int decoded_size = 0;
int coded_size = 0;
int32 decoded_size = 0;
int32 coded_size = 0;
#endif
do {
int code = src.getByte();
int length = (code >> 1) + 1;
int32 code = src.getByte();
int32 length = (code >> 1) + 1;
size -= length;
#ifdef DEBUG_CODEC37_PROC2
decoded_size += length;
@ -258,11 +258,11 @@ void Codec37Decoder::proc2(Blitter & dst, Chunk & src, int size) { // This is co
} while (size);
}
void Codec37Decoder::proc3WithFDFE(Blitter & dst, Chunk & src, int next_offs, int bw, int bh) {
void Codec37Decoder::proc3WithFDFE(Blitter & dst, Chunk & src, int32 next_offs, int32 bw, int32 bh) {
do {
int i = bw;
int32 i = bw;
do {
int code = src.getByte();
int32 code = src.getByte();
if (code == 0xFD) {
#ifdef USE_COLOR_CODE_FOR_BLOCK
dst.putBlock(expand(1));
@ -293,11 +293,11 @@ void Codec37Decoder::proc3WithFDFE(Blitter & dst, Chunk & src, int next_offs, in
} while (--bh);
}
void Codec37Decoder::proc3WithoutFDFE(Blitter & dst, Chunk & src, int next_offs, int bw, int bh) {
void Codec37Decoder::proc3WithoutFDFE(Blitter & dst, Chunk & src, int32 next_offs, int32 bw, int32 bh) {
do {
int i = bw;
int32 i = bw;
do {
int code = src.getByte();
int32 code = src.getByte();
if (code == 0xFF) {
#ifdef USE_COLOR_CODE_FOR_BLOCK
dst.putBlock(expand(5));
@ -316,11 +316,11 @@ void Codec37Decoder::proc3WithoutFDFE(Blitter & dst, Chunk & src, int next_offs,
} while (--bh);
}
void Codec37Decoder::proc4(Blitter & dst, Chunk & src, int next_offs, int bw, int bh) {
void Codec37Decoder::proc4(Blitter & dst, Chunk & src, int32 next_offs, int32 bw, int32 bh) {
do {
int i = bw;
int32 i = bw;
do {
int code = src.getByte();
int32 code = src.getByte();
if (code == 0xFD) {
#ifdef USE_COLOR_CODE_FOR_BLOCK
dst.putBlock(expand(7));
@ -340,8 +340,8 @@ void Codec37Decoder::proc4(Blitter & dst, Chunk & src, int next_offs, int bw, in
dst.putBlock(src);
#endif
} else if (code == 0x00) {
int length = src.getByte() + 1;
for (int l = 0; l < length; l++) {
int32 length = src.getByte() + 1;
for (int32 l = 0; l < length; l++) {
#ifdef USE_COLOR_CODE_FOR_BLOCK
dst.putBlock(expand(10));
#else
@ -369,24 +369,24 @@ void Codec37Decoder::proc4(Blitter & dst, Chunk & src, int next_offs, int bw, in
}
bool Codec37Decoder::decode(Blitter & dst, Chunk & src) {
int width = getRect().width();
int height = getRect().height();
int bw = (width + 3) >> 2, bh = (height + 3) >> 2;
int pitch = bw << 2;
int32 width = getRect().width();
int32 height = getRect().height();
int32 bw = (width + 3) >> 2, bh = (height + 3) >> 2;
int32 pitch = bw << 2;
#ifdef DEBUG_CODEC37
debug(7, "codec37::decode() : width == %d : height == %d : pitch == %d : _prevSeqNb == %d",
width, height, pitch, _prevSeqNb);
#endif
int code = src.getByte(); // 0 -> 1 (1)
int index = src.getByte(); // 1 -> 2 (1)
unsigned short seq_nb = src.getWord(); // 2 -> 4 (2)
unsigned int decoded_size = src.getDword(); // 4 -> 8 (4)
int32 code = src.getByte(); // 0 -> 1 (1)
int32 index = src.getByte(); // 1 -> 2 (1)
uint16 seq_nb = src.getWord(); // 2 -> 4 (2)
uint32 decoded_size = src.getDword(); // 4 -> 8 (4)
#ifdef DEBUG_CODEC37
unsigned int coded_size = src.getDword(); // 8 -> 12 (4)
uint32 coded_size = src.getDword(); // 8 -> 12 (4)
#else
src.seek(4);
#endif
unsigned int mask_flag = src.getDword(); // 12 -> 16 (4)
uint32 mask_flag = src.getDword(); // 12 -> 16 (4)
#ifdef DEBUG_CODEC37
debug(7, "codec37::decode() : code == %d : index == %d : seq_nb == %d : decoded_size == %d : coded_size == %d : mask_flag == %d",
code, index, seq_nb, decoded_size, coded_size, mask_flag);
@ -396,7 +396,7 @@ bool Codec37Decoder::decode(Blitter & dst, Chunk & src) {
assert(seq_nb && _prevSeqNb + 1 == seq_nb);
if (seq_nb & 1 || !(mask_flag & 1)) _curtable ^= 1;
}
Blitter blit((char *)_deltaBufs[_curtable], Point(width, height), Rect(0, 0, width, height));
Blitter blit((byte *)_deltaBufs[_curtable], Point(width, height), Rect(0, 0, width, height));
switch(code) {
case 0:
memset(_deltaBuf, 0, _deltaBufs[_curtable] - _deltaBuf);
@ -426,7 +426,7 @@ bool Codec37Decoder::decode(Blitter & dst, Chunk & src) {
#endif
break;
}
dst.blit((char*)_deltaBufs[_curtable], width * height);
dst.blit((byte *)_deltaBufs[_curtable], width * height);
_prevSeqNb = seq_nb;
return true;
}

32
scumm/smush/codec37.h
View file

@ -54,14 +54,14 @@
class Codec37Decoder : public Decoder {
private:
int _deltaSize;
unsigned char * _deltaBufs[2];
unsigned char * _deltaBuf;
short * _offsetTable;
int _curtable;
unsigned short _prevSeqNb;
int _tableLastPitch;
int _tableLastIndex;
int32 _deltaSize;
byte * _deltaBufs[2];
byte * _deltaBuf;
int16 * _offsetTable;
int32 _curtable;
uint16 _prevSeqNb;
int32 _tableLastPitch;
int32 _tableLastIndex;
public:
bool initSize(const Point &, const Rect &);
@ -69,16 +69,16 @@ public:
void clean();
virtual ~Codec37Decoder();
protected:
static inline unsigned int expand(unsigned char b) {
unsigned int r = b | (b << 8);
static inline uint32 expand(byte b) {
uint32 r = b | (b << 8);
return r | (r << 16);
}
void maketable(int, int);
void proc1(Blitter &, Chunk &, int, int, int, int);
void proc2(Blitter &, Chunk &, int);
void proc3WithFDFE(Blitter &, Chunk &, int, int, int);
void proc3WithoutFDFE(Blitter &, Chunk &, int, int, int);
void proc4(Blitter &, Chunk &, int, int, int);
void maketable(int32, int32);
void proc1(Blitter &, Chunk &, int32, int32, int32, int32);
void proc2(Blitter &, Chunk &, int32);
void proc3WithFDFE(Blitter &, Chunk &, int32, int32, int32);
void proc3WithoutFDFE(Blitter &, Chunk &, int32, int32, int32);
void proc4(Blitter &, Chunk &, int32, int32, int32);
public:
bool decode(Blitter &, Chunk &);
};

8
scumm/smush/codec44.cpp
View file

@ -25,10 +25,10 @@
#include "blitter.h"
bool Codec44Decoder::decode(Blitter & dst, Chunk & src) {
int size_line;
int num;
int w, width = getRect().width() + 1;
int h, height = getRect().height() + 1;
int32 size_line;
int32 num;
int32 w, width = getRect().width() + 1;
int32 h, height = getRect().height() + 1;
bool zero;
#ifdef DEBUG_CODEC44
debug(7, "codec44 : %dx%d", width, height);

14
scumm/smush/codec47.cpp
View file

@ -28,18 +28,18 @@ DumpDecoder::~DumpDecoder() {
}
bool DumpDecoder::decode(Blitter & dst, Chunk & src) {
int i = 0;
int seq = src.getWord();
int codec = src.getByte();
int flags = src.getByte();
int unknown[22];
int32 i = 0;
int32 seq = src.getWord();
int32 codec = src.getByte();
int32 flags = src.getByte();
int32 unknown[22];
for(i = 0; i < 0; i++) {
unknown[i] = src.getByte();
}
if(codec == 5 || codec == 1) {
do {
int code = src.getByte();
int length = (code >> 1) + 1;
int32 code = src.getByte();
int32 length = (code >> 1) + 1;
if (code & 1)
dst.put(src.getChar(), length);
else

6
scumm/smush/color.cpp
View file

@ -22,12 +22,12 @@
#include <stdafx.h>
#include "color.h"
#define UPDATE_COLOR(c, inc) (((int)((c)) << 7) + (c) + (inc)) >> 7
#define UPDATE_COLOR(c, inc) (((int32)((c)) << 7) + (c) + (inc)) >> 7
#define CHECK_BOUNDS(c) (((c) > 255) ? 255 : (((c) < 0) ? 0 : (c)))
void Color::delta(short * ptr) {
void Color::delta(int16 * ptr) {
// This is a very specific method for XPALs.
int t;
int16 t;
t = UPDATE_COLOR(_r, ptr[0]);
_r = CHECK_BOUNDS(t);
t = UPDATE_COLOR(_g, ptr[1]);

4
scumm/smush/color.h
View file

@ -30,7 +30,7 @@
*/
class Color {
public:
typedef unsigned char value_type; //!< The type of the Chunk components.
typedef byte value_type; //!< The type of the Chunk components.
private:
value_type _r; //!< The red component.
value_type _g; //!< The green component.
@ -49,7 +49,7 @@ public:
@param ptr pointer to a table of 3 shorts that contain delta values to use.
*/
void delta(short * ptr);
void delta(int16 * ptr);
};
#endif

79
scumm/smush/frenderer.cpp
View file

@ -26,18 +26,21 @@
#include "rect.h"
#include <assert.h>
#include <string.h> // for memcpy, strcat, strdup
#include <string.h>
FontRenderer::FontRenderer(bool use_original_colors) : _nbChars(0), _color(-1), _original(use_original_colors) {
FontRenderer::FontRenderer(bool use_original_colors) :
_nbChars(0),
_color(-1),
_original(use_original_colors) {
}
FontRenderer::~FontRenderer() {
for(int i = 0; i < _nbChars; i++) {
for(int32 i = 0; i < _nbChars; i++) {
if(_chars[i].chr) delete []_chars[i].chr;
}
}
void FontRenderer::save(int frame) {
void FontRenderer::save(int32 frame) {
_chars[_nbChars].width = getWidth();
_chars[_nbChars].height = getHeight();
int size = getWidth() * getHeight();
@ -46,20 +49,20 @@ void FontRenderer::save(int frame) {
_nbChars++;
}
int FontRenderer::charWidth(int v) const {
int32 FontRenderer::charWidth(int32 v) const {
if(v < 0) v = 256 + v;
if(v < 0 || v >= _nbChars) error("invalid character in FontRenderer::charWidth : %d (%d)", v, _nbChars);
return _chars[v].width;
}
int FontRenderer::charHeight(int v) const {
int32 FontRenderer::charHeight(int32 v) const {
if(v < 0) v = 256 + v;
if(v < 0 || v >= _nbChars) error("invalid character in FontRenderer::charHeight : %d (%d)", v, _nbChars);
return _chars[v].height;
}
int FontRenderer::stringWidth(const char * str) const {
int ret = 0;
int32 FontRenderer::stringWidth(const char * str) const {
int32 ret = 0;
while(*str) {
ret += charWidth(*str++);
@ -68,36 +71,36 @@ int FontRenderer::stringWidth(const char * str) const {
return ret;
}
int FontRenderer::stringHeight(const char * str) const {
int ret = 0;
int32 FontRenderer::stringHeight(const char * str) const {
int32 ret = 0;
for(int i = 0; str[i] != 0; i++) {
int h = charHeight(str[i]);
for(int32 i = 0; str[i] != 0; i++) {
int32 h = charHeight(str[i]);
ret = MAX(ret, h);
}
return ret;
}
int FontRenderer::drawChar(char * buffer, const Point & size, int x, int y, int chr) const {
int w = _chars[chr].width;
int h = _chars[chr].height;
int32 FontRenderer::drawChar(char * buffer, const Point & size, int32 x, int32 y, int32 chr) const {
int32 w = _chars[chr].width;
int32 h = _chars[chr].height;
char * src = _chars[chr].chr;
char * dst = buffer + size.getX() * y + x;
if(_original) {
for(int j = 0; j < h; j++) {
for(int i = 0; i < w; i++) {
int value = *src++;
for(int32 j = 0; j < h; j++) {
for(int32 i = 0; i < w; i++) {
char value = *src++;
if(value) dst[i] = value;
}
dst += size.getX();
}
} else {
int color = (_color != -1) ? _color : 1;
for(int j = 0; j < h; j++) {
for(int i = 0; i < w; i++) {
int value = *src++;
char color = (_color != -1) ? _color : 1;
for(int32 j = 0; j < h; j++) {
for(int32 i = 0; i < w; i++) {
char value = *src++;
if(value == 1) {
dst[i] = color;
} else if(value) {
@ -112,7 +115,7 @@ int FontRenderer::drawChar(char * buffer, const Point & size, int x, int y, int
static char * * split(const char * str, char sep) {
char * * ret = new char *[32];
int n = 0;
int32 n = 0;
const char * i = str, * j = strchr(i, sep);
while(j != NULL) {
@ -131,12 +134,12 @@ static char * * split(const char * str, char sep) {
return ret;
}
void FontRenderer::drawSubstring(const unsigned char * str, char * buffer, const Point & size, int x, int y) const {
for(int i = 0; str[i] != 0; i++)
void FontRenderer::drawSubstring(const byte * str, char * buffer, const Point & size, int32 x, int32 y) const {
for(int32 i = 0; str[i] != 0; i++)
x += drawChar(buffer, size, x, y, str[i]);
}
bool FontRenderer::drawStringAbsolute(const char * str, char * buffer, const Point & size, int x, int y) const {
bool FontRenderer::drawStringAbsolute(const char * str, char * buffer, const Point & size, int32 x, int32 y) const {
debug(9, "FontRenderer::drawStringAbsolute(%s, %d, %d)", str, x, y);
while(str) {
char line[256];
@ -149,42 +152,42 @@ bool FontRenderer::drawStringAbsolute(const char * str, char * buffer, const Poi
strcpy(line, str);
str = 0;
}
drawSubstring((const unsigned char *)line, buffer, size, x, y);
drawSubstring((const byte *)line, buffer, size, x, y);
y += stringHeight(line);
}
return true;
}
bool FontRenderer::drawStringCentered(const char * str, char * buffer, const Point & size, int y, int xmin, int width, int offset) const {
bool FontRenderer::drawStringCentered(const char * str, char * buffer, const Point & size, int32 y, int32 xmin, int32 width, int32 offset) const {
debug(9, "FontRenderer::drawStringCentered(%s, %d, %d)", str, xmin, y);
assert(strchr(str, '\n') == 0);
char * * words = split(str, ' ');
int nb_sub = 0;
int32 nb_sub = 0;
while(words[nb_sub]) nb_sub++;
int * sizes = new int[nb_sub];
int i = 0, max_width = 0, height = 0, nb_subs = 0;
int32 * sizes = new int32[nb_sub];
int32 i = 0, max_width = 0, height = 0, nb_subs = 0;
for(i = 0; i < nb_sub; i++)
sizes[i] = stringWidth(words[i]);
char * * substrings = new char *[nb_sub];
int * substr_widths = new int[nb_sub];
int space_width = charWidth(' ');
int32 * substr_widths = new int32[nb_sub];
int32 space_width = charWidth(' ');
i = 0;
while(i < nb_sub) {
int substr_width = sizes[i];
int32 substr_width = sizes[i];
char * substr = new char[1000];
strcpy(substr, words[i]);
int j = i + 1;
int32 j = i + 1;
while(j < nb_sub && (substr_width + space_width + sizes[j]) < width) {
substr_width += sizes[j++] + space_width;
}
for(int k = i + 1; k < j; k++) {
for(int32 k = i + 1; k < j; k++) {
strcat(substr, " ");
strcat(substr, words[k]);
}
@ -219,8 +222,8 @@ bool FontRenderer::drawStringCentered(const char * str, char * buffer, const Poi
}
for(i = 0; i < nb_subs; i++) {
int substr_width = substr_widths[i];
drawSubstring((const unsigned char *)substrings[i], buffer, size, x - substr_width / 2, y);
int32 substr_width = substr_widths[i];
drawSubstring((const byte *)substrings[i], buffer, size, x - substr_width / 2, y);
y += stringHeight(substrings[i]);
delete []substrings[i];
}

30
scumm/smush/frenderer.h
View file

@ -50,12 +50,12 @@
*/
class FontRenderer : public BaseRenderer {
private:
int _nbChars; //!< The number of frames in the font
int _color; //!< A color parameter used for font printing.
int32 _nbChars; //!< The number of frames in the font
int32 _color; //!< A color parameter used for font printing.
bool _original; //!< flag for color selection
struct {
int width;
int height;
int32 width;
int32 height;
char * chr;
} _chars[256]; //!< array that contains the size of the different frames (i.e. characters) of the font.
public:
@ -65,37 +65,37 @@ public:
*/
FontRenderer(bool use_original_colors = false);
virtual ~FontRenderer();
virtual bool wait(int ms) { return true; };
virtual bool wait(int32 ms) { return true; };
protected:
virtual void save(int frame = -1);
virtual void save(int32 frame = -1);
/*! @brief get the width of a character.
@param c the character we want the width from.
@return the width of the character
*/
int charWidth(int c) const;
int32 charWidth(int32 c) const;
/*! @brief get the width of a string.
@param str the string we want the width from.
@return the complete width of the string
*/
int stringWidth(const char * str) const;
int32 stringWidth(const char * str) const;
/*! @brief get the height of a character.
@param c the character we want the height from.
@return the height of the character
*/
int charHeight(int c) const;
int32 charHeight(int32 c) const;
/*! @brief get the height of a string.
@param str the string we want the height from.
@return the complete height of the string
*/
int stringHeight(const char * str) const;
int32 stringHeight(const char * str) const;
/*! @brief draw a character in the given frame buffer.
@param buffer the frame buffer to draw into.
@ -108,7 +108,7 @@ protected:
@return the width of the character
*/
int drawChar(char * buffer, const Point & size, int x, int y, int c) const;
int32 drawChar(char * buffer, const Point & size, int32 x, int32 y, int32 c) const;
/*! @brief draw a string in the given frame buffer.
@param str the string to draw.
@ -119,7 +119,7 @@ protected:
@bug This method does not clip. This is not really a bug, as it should always be correctly called, but some asserts would be welcome.
*/
void drawSubstring(const unsigned char * str, char * buffer, const Point & size, int x, int y) const;
void drawSubstring(const byte * str, char * buffer, const Point & size, int32 x, int32 y) const;
public:
/*! @brief change the programmable color of the font.
@ -127,7 +127,7 @@ public:
@return \c true if everything went fine, \c false otherwise
*/
bool setColor(int c) { _color = c; return true; }
bool setColor(int32 c) { _color = c; return true; }
/*! @brief draw a centered and possibly using multiple lines string.
This method performs calculation of the string size before choosing where to draw it.
@ -147,7 +147,7 @@ public:
@return \c true if everything went fine, \c false otherwise
*/
bool drawStringCentered(const char * str, char * buffer, const Point & size, int y, int xmin, int width, int offset) const;
bool drawStringCentered(const char * str, char * buffer, const Point & size, int32 y, int32 xmin, int32 width, int32 offset) const;
/*! @brief draw a string at an absolute position.
@param str the string to draw.
@ -158,7 +158,7 @@ public:
@return \c true if everything went fine, \c false otherwise
*/
bool drawStringAbsolute(const char * str, char * buffer, const Point & size, int x, int y) const;
bool drawStringAbsolute(const char * str, char * buffer, const Point & size, int32 x, int32 y) const;
};

83
scumm/smush/imuse_channel.cpp
View file

@ -25,9 +25,9 @@
#include "chunk_type.h"
#include <assert.h>
#include <string.h> // for memcpy.h
#include <string.h>
ImuseChannel::ImuseChannel(int track, int freq) :
ImuseChannel::ImuseChannel(int32 track, int32 freq) :
_track(track),
_tbuffer(0),
_tbufferSize(0),
@ -52,32 +52,32 @@ bool ImuseChannel::isTerminated() const {
return (_dataSize <= 0 && _sbuffer == 0);
}
bool ImuseChannel::setParameters(int nbframes, int size, int unk1, int unk2) {
bool ImuseChannel::setParameters(int32 nbframes, int32 size, int32 unk1, int32 unk2) {
return true;
}
bool ImuseChannel::checkParameters(int index, int nbframes, int size, int unk1, int unk2) {
bool ImuseChannel::checkParameters(int32 index, int32 nbframes, int32 size, int32 unk1, int32 unk2) {
return true;
}
bool ImuseChannel::appendData(Chunk & b, int size) {
bool ImuseChannel::appendData(Chunk & b, int32 size) {
if(_dataSize == -1) { // First call
assert(size > 8);
Chunk::type imus_type = b.getDword(); imus_type = SWAP_BYTES(imus_type);
unsigned int imus_size = b.getDword(); imus_size = SWAP_BYTES(imus_size);
uint32 imus_size = b.getDword(); imus_size = SWAP_BYTES(imus_size);
if(imus_type != TYPE_iMUS) error("Invalid Chunk for imuse_channel");
size -= 8;
_tbufferSize = size;
assert(_tbufferSize);
_tbuffer = new unsigned char[_tbufferSize];
_tbuffer = new byte[_tbufferSize];
if(!_tbuffer) error("imuse_channel failed to allocate memory");
b.read(_tbuffer, size);
_dataSize = -2; // even if _in_data does not get set, this won't be called again
} else {
if(_tbuffer) { // remaining from last call
unsigned char * old = _tbuffer;
int new_size = size + _tbufferSize;
_tbuffer = new unsigned char[new_size];
byte * old = _tbuffer;
int32 new_size = size + _tbufferSize;
_tbuffer = new byte[new_size];
if(!_tbuffer) error("imuse_channel failed to allocate memory");
memcpy(_tbuffer, old, _tbufferSize);
delete []old;
@ -85,7 +85,7 @@ bool ImuseChannel::appendData(Chunk & b, int size) {
_tbufferSize += size;
} else {
_tbufferSize = size;
_tbuffer = new unsigned char[_tbufferSize];
_tbuffer = new byte[_tbufferSize];
if(!_tbuffer) error("imuse_channel failed to allocate memory");
b.read(_tbuffer, size);
}
@ -95,7 +95,7 @@ bool ImuseChannel::appendData(Chunk & b, int size) {
bool ImuseChannel::handleFormat(Chunk & src) {
if(src.getSize() != 20) error("invalid size for FRMT Chunk");
unsigned imuse_start = src.getDword();
uint32 imuse_start = src.getDword();
imuse_start = SWAP_BYTES(imuse_start);
src.seek(4);
_bitsize = src.getDword();
@ -152,16 +152,16 @@ void ImuseChannel::decode() {
_srbufferSize -= remaining_size;
assert(_inData);
if(_tbuffer == 0) {
_tbuffer = new unsigned char[remaining_size];
_tbuffer = new byte[remaining_size];
memcpy(_tbuffer, _sbuffer + _sbufferSize - remaining_size, remaining_size);
_tbufferSize = remaining_size;
_sbufferSize -= remaining_size;
} else {
warning("impossible ! : %p, %d, %d, %p(%d), %p(%d, %d)",
this, _dataSize, _inData, _tbuffer, _tbufferSize, _sbuffer, _sbufferSize, _srbufferSize);
unsigned char * old = _tbuffer;
byte * old = _tbuffer;
int new_size = remaining_size + _tbufferSize;
_tbuffer = new unsigned char[new_size];
_tbuffer = new byte[new_size];
if(!_tbuffer) error("imuse_channel failed to allocate memory");
memcpy(_tbuffer, old, _tbufferSize);
delete []old;
@ -172,7 +172,7 @@ void ImuseChannel::decode() {
int loop_size = _sbufferSize / 3;
int new_size = loop_size * 2;
short * keep, * decoded;
keep = decoded = new short[new_size];
keep = decoded = new int16[new_size];
assert(keep);
unsigned char * source = _sbuffer;
while(loop_size--) {
@ -180,25 +180,25 @@ void ImuseChannel::decode() {
int v2 = *source++;
int v3 = *source++;
int value = (((v2 & 0x0f) << 12) | (v1 << 4)) - 0x8000;
*decoded++ = (short)value;
*decoded++ = (int16)value;
value = (((v2 & 0xf0) << 8) | (v3 << 4)) - 0x8000;
*decoded++ = (short)value;
*decoded++ = (int16)value;
}
delete []_sbuffer;
_sbuffer = (unsigned char*)keep;
_sbufferSize = new_size * sizeof(short);
_sbuffer = (byte *)keep;
_sbufferSize = new_size * sizeof(int16);
}
bool ImuseChannel::handleSubTags(int & offset) {
bool ImuseChannel::handleSubTags(int32 & offset) {
if(_tbufferSize - offset >= 8) {
Chunk::type type = READ_BE_UINT32(_tbuffer + offset);
unsigned int size = READ_BE_UINT32(_tbuffer + offset + 4);
unsigned int available_size = _tbufferSize - offset;
uint32 size = READ_BE_UINT32(_tbuffer + offset + 4);
uint32 available_size = _tbufferSize - offset;
switch(type) {
case TYPE_MAP_:
_inData = false;
if(available_size >= (size + 8)) {
ContChunk c((char*)_tbuffer + offset);
ContChunk c((byte *)_tbuffer + offset);
handleMap(c);
}
break;
@ -208,8 +208,10 @@ bool ImuseChannel::handleSubTags(int & offset) {
offset += 8;
{
int reqsize = 1;
if(_channels == 2) reqsize *= 2;
if(_bitsize == 16) reqsize *= 2;
if(_channels == 2)
reqsize *= 2;
if(_bitsize == 16)
reqsize *= 2;
else if(_bitsize == 12) {
if(reqsize > 1)
reqsize = reqsize * 3 / 2;
@ -239,13 +241,13 @@ bool ImuseChannel::processBuffer() {
if(_inData) {
if(_dataSize < _tbufferSize) {
int offset= _dataSize;
int32 offset= _dataSize;
while(handleSubTags(offset));
_sbufferSize = _dataSize;
_sbuffer = _tbuffer;
if(offset < _tbufferSize) { // there is still some unprocessed data
int new_size = _tbufferSize - offset;
_tbuffer = new unsigned char[new_size];
int32 new_size = _tbufferSize - offset;
_tbuffer = new byte[new_size];
if(!_tbuffer) error("imuse_channel failed to allocate memory");
memcpy(_tbuffer, _sbuffer + offset, new_size);
_tbufferSize = new_size;
@ -266,13 +268,12 @@ bool ImuseChannel::processBuffer() {
_tbuffer = 0;
}
} else {
int offset = 0;
int32 offset = 0;
while(handleSubTags(offset));
if(_inData) {
//~ unsigned char * old = _tbuffer;
_sbufferSize = _tbufferSize - offset;
assert(_sbufferSize);
_sbuffer = new unsigned char[_sbufferSize];
_sbuffer = new byte[_sbufferSize];
if(!_sbuffer) error("imuse_channel failed to allocate memory");
memcpy(_sbuffer, _tbuffer + offset, _sbufferSize);
delete []_tbuffer;
@ -280,9 +281,9 @@ bool ImuseChannel::processBuffer() {
_tbufferSize = 0;
} else {
if(offset) { // maybe I should assert() this to avoid a lock...
unsigned char * old = _tbuffer;
int new_size = _tbufferSize - offset;
_tbuffer = new unsigned char[new_size];
byte * old = _tbuffer;
int32 new_size = _tbufferSize - offset;
_tbuffer = new byte[new_size];
if(!_tbuffer) error("imuse_channel failed to allocate memory");
memcpy(_tbuffer, old + offset, new_size);
_tbufferSize = new_size;
@ -295,17 +296,17 @@ bool ImuseChannel::processBuffer() {
return true;
}
int ImuseChannel::availableSoundData(void) const {
int ret = _sbufferSize;
int32 ImuseChannel::availableSoundData(void) const {
int32 ret = _sbufferSize;
if(_channels == 2) ret /= 2;
if(_bitsize > 8) ret /= 2;
return ret;
}
void ImuseChannel::getSoundData(short * snd, int size) {
void ImuseChannel::getSoundData(int16 * snd, int32 size) {
if(_dataSize <= 0 || _bitsize <= 8) error("invalid call to imuse_channel::read_sound_data()");
if(_channels == 2) size *= 2;
for(int i = 0; i < size; i++)
for(int32 i = 0; i < size; i++)
snd[i] = READ_BE_UINT16(_sbuffer + 2 * i);
delete []_sbuffer;
assert(_sbufferSize == 2 * size);
@ -314,10 +315,10 @@ void ImuseChannel::getSoundData(short * snd, int size) {
_dataSize -= _srbufferSize;
}
void ImuseChannel::getSoundData(char * snd, int size) {
void ImuseChannel::getSoundData(int8 * snd, int32 size) {
if(_dataSize <= 0 || _bitsize > 8) error("invalid call to imuse_channel::read_sound_data()");
if(_channels == 2) size *= 2;
for(int i = 0; i < size; i++)
for(int32 i = 0; i < size; i++)
snd[i] = _sbuffer[i];
delete []_sbuffer;
_sbuffer = 0;

2
scumm/smush/mixer.h
View file

@ -49,7 +49,7 @@ class Mixer {
public:
virtual ~Mixer() {};
virtual bool init() = 0;
virtual _Channel * findChannel(int track) = 0;
virtual _Channel * findChannel(int32 track) = 0;
virtual bool addChannel(_Channel * c) = 0;
virtual bool handleFrame() = 0;
virtual bool stop() = 0;

8
scumm/smush/palette.h
View file

@ -35,19 +35,19 @@ private:
Color _colors[256];
public:
Palette() {}
Palette(unsigned char *ptr)
Palette(byte *ptr)
{
for(int i = 0; i < 256; i++) {
for(int32 i = 0; i < 256; i++) {
_colors[i] = Color(ptr[3 * i + 0], ptr[3 * i + 1], ptr[3 * i + 2]);
}
}
const Color & operator[](int a) const
const Color & operator[](int32 a) const
{
assert(a >= 0 && a < 256);
return _colors[a];
}
Color & operator[](int a)
Color & operator[](int32 a)
{
assert(a >= 0 && a < 256);
return _colors[a];

144
scumm/smush/player.cpp
View file

@ -32,10 +32,10 @@
#include "blitter.h"
#include <assert.h>
#include <stdlib.h> // for atoi
#include <stdio.h> // for FILE, fopen, fclose, fread, fseek, ftell
#include <string.h> // for strchr, strrchr
#include <ctype.h> // for isdigit
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
const int WAIT = 100;
@ -47,21 +47,21 @@ const int WAIT = 100;
@bug some of The Dig strings are not completely parsed (in titles)
*/
const int MAX_STRINGS = 200;
const int32 MAX_STRINGS = 200;
class StringResource {
private:
struct {
int id;
int32 id;
char * string;
} _strings[MAX_STRINGS];
int _nbStrings;
int _lastId;
int32 _nbStrings;
int32 _lastId;
char * _lastString;
public:
StringResource() : _nbStrings(0), _lastId(-1) {};
~StringResource() {
for(int i = 0; i < _nbStrings; i++) {
for(int32 i = 0; i < _nbStrings; i++) {
delete []_strings[i].string;
}
}
@ -72,7 +72,7 @@ public:
@return \c true if the parsing went fine, \c false otherwise
*/
bool init(char * buffer, int length) {
bool init(char * buffer, int32 length) {
debug(9, "parsing string resources...");
char * def_start = strchr(buffer, '#');
while(def_start != NULL) {
@ -87,11 +87,13 @@ public:
char idstring[32];
memcpy(idstring, id_start, id_end - id_start);
idstring[id_end - id_start] = 0;
int id = atoi(idstring);
//~ assert(id != LONG_MIN && id != 0 && id != LONG_MAX);
int32 id = atoi(idstring);
char * data_start = def_end;
while(*data_start == '\n' || *data_start == '\r') data_start++;
while(*data_start == '\n' || *data_start == '\r')
data_start++;
char * data_end = data_start;
while(1) {
if(data_end[-2] == '\r' && data_end[1] == '\n' && data_end[-1] == '\n' && data_end[0] == '\r')
break;
@ -101,6 +103,7 @@ public:
break;
}
}
data_end -= 2;
assert(data_end > data_start);
char * value = new char[data_end - data_start + 1];
@ -109,6 +112,7 @@ public:
value[data_end - data_start] = 0;
char * line_start = value;
char * line_end;
while ((line_end = strchr(line_start, '\n'))) {
line_start = line_end+1;
if (line_start[0] == '/' && line_start[1] == '/') {
@ -136,7 +140,7 @@ public:
@return the corresponding string.
*/
const char * get(int id) {
const char * get(int32 id) {
if(id == _lastId) return _lastString;
for(int i = 0; i < _nbStrings; i++)
{
@ -175,7 +179,7 @@ void SmushPlayer::hide(const char * p) {
else if(strcmp(p, "voices") == 0)
_voices = false;
else {
int id = atoi(p);
int32 id = atoi(p);
if(id < 0 || id > 36) error("invalid parameter to hide");
_skips[id] = false;
}
@ -221,7 +225,7 @@ void SmushPlayer::clean() {
if(_fr[3]) delete _fr[3];
}
void SmushPlayer::checkBlock(const Chunk & b, Chunk::type type_expected, unsigned int min_size) {
void SmushPlayer::checkBlock(const Chunk & b, Chunk::type type_expected, uint32 min_size) {
if(type_expected != b.getType()) {
error("Chunk type is different from expected : %d != %d", b.getType(), type_expected);
}
@ -230,7 +234,7 @@ void SmushPlayer::checkBlock(const Chunk & b, Chunk::type type_expected, unsigne
}
}
void SmushPlayer::handleSoundBuffer(int track_id, int index, int max_frames, int flags, int vol, int bal, Chunk & b, int size) {
void SmushPlayer::handleSoundBuffer(int32 track_id, int32 index, int32 max_frames, int32 flags, int32 vol, int32 bal, Chunk & b, int32 size) {
debug(6, "smush_player::handleSoundBuffer(%d)", track_id);
if(!_voices && (flags & 128) == 128) return;
if(!_bgmusic && (flags & 64) == 64) return;
@ -250,24 +254,24 @@ void SmushPlayer::handleSoundFrame(Chunk & b) {
checkBlock(b, TYPE_PSAD);
debug(6, "SmushPlayer::handleSoundFrame()");
if(!_outputSound) return;
int track_id = b.getWord();
int index = b.getWord();
int max_frames = b.getWord();
int flags = b.getWord();
int vol = b.getByte();
int bal = b.getChar();
int32 track_id = b.getWord();
int32 index = b.getWord();
int32 max_frames = b.getWord();
int32 flags = b.getWord();
int32 vol = b.getByte();
int32 bal = b.getChar();
#ifdef DEBUG
if(index == 0) {
debug(5, "track_id == %d, max_frames == %d, %d, %d, %d", track_id, max_frames, flags, vol, bal);
}
#endif
int size = b.getSize() - 10;
int32 size = b.getSize() - 10;
handleSoundBuffer(track_id, index, max_frames, flags, vol, bal, b, size);
}
void SmushPlayer::handleSkip(Chunk & b) {
checkBlock(b, TYPE_SKIP, 4);
int code = b.getDword();
int32 code = b.getDword();
debug(6, "SmushPlayer::handleSkip(%d)", code);
if(code >= 0 && code < 37)
_skipNext = _skips[code];
@ -285,7 +289,7 @@ void SmushPlayer::handleFetch(Chunk & b) {
debug(6, "SmushPlayer::handleFetch()");
}
void SmushPlayer::handleImuseBuffer(int track_id, int index, int nbframes, int size, int unk1, int unk2, Chunk & b, int bsize) {
void SmushPlayer::handleImuseBuffer(int32 track_id, int32 index, int32 nbframes, int32 size, int32 unk1, int32 unk2, Chunk & b, int32 bsize) {
_Channel * c = _mixer->findChannel(track_id);
if(c == 0) {
c = new ImuseChannel(track_id, _soundFrequency);
@ -298,14 +302,14 @@ void SmushPlayer::handleImuseBuffer(int track_id, int index, int nbframes, int s
c->appendData(b, bsize);
}
void SmushPlayer::handleImuseAction8(Chunk & b, int flags, int unknown, int track_id) {
void SmushPlayer::handleImuseAction8(Chunk & b, int32 flags, int32 unknown, int32 track_id) {
assert(flags == 46 && unknown == 0);
int unknown2 = b.getWord();
int32 unknown2 = b.getWord();
track_id |= unknown2 << 16;
int index = b.getWord();
int nbframes = b.getWord();
int size = b.getDword();
int bsize = b.getSize() - 18;
int32 index = b.getWord();
int32 nbframes = b.getWord();
int32 size = b.getDword();
int32 bsize = b.getSize() - 18;
handleImuseBuffer(track_id, index, nbframes, size, unknown, unknown2, b, bsize);
}
@ -313,10 +317,10 @@ void SmushPlayer::handleImuseAction(Chunk & b) {
checkBlock(b, TYPE_IACT, 8);
debug(6, "SmushPlayer::handleImuseAction()");
if(!_outputSound) return;
int code = b.getWord();
int flags = b.getWord();
int unknown = b.getShort();
int track_id = b.getWord();
int32 code = b.getWord();
int32 flags = b.getWord();
int32 unknown = b.getShort();
int32 track_id = b.getWord();
#ifdef DEBUG
debug(5, "handleImuseAction(%d, %d, %d, %d)", code, flags, unknown, track_id);
#endif
@ -334,42 +338,36 @@ void SmushPlayer::handleImuseAction(Chunk & b) {
void SmushPlayer::handleTextResource(Chunk & b) {
checkBlock(b, TYPE_TRES, 18);
int pos_x = b.getShort();
int pos_y = b.getShort();
int flags = b.getShort();
int left = b.getShort();
int top = b.getShort();
int width = b.getShort();
int height = b.getShort();
int unk2 = b.getWord();
int string_id = b.getWord();
int32 pos_x = b.getShort();
int32 pos_y = b.getShort();
int32 flags = b.getShort();
int32 left = b.getShort();
int32 top = b.getShort();
int32 width = b.getShort();
int32 height = b.getShort();
int32 unk2 = b.getWord();
int32 string_id = b.getWord();
debug(6, "SmushPlayer::handleTextResource(%d)", string_id);
if(!_strings) return;
// if subtitles disabled and bit 3 is set, then do not draw
if((!_subtitles) && ((flags & 8) == 8)) return;
if((!_subtitles) && ((flags & 8) == 8))
return;
const char * str = _strings->get(string_id);
FontRenderer * fr = _fr[0];
int color = 15;
int32 color = 15;
while(*str == '/') str++; // For Full Throttle text resources
while(str[0] == '^') {
switch(str[1]) {
case 'f':
{
#if 0
// This cause trouble if the next character is a digit.
int id = atoi(str+2);
#else
// assume ASCII like character set...
int id = str[3] - '0';
#endif
str += 4;
fr = _fr[id];
} break;
case 'c':
{
//~ int id = atoi(str+2);
color = str[4] - '0' + 10 *(str[3] - '0');
str += 5;
} break;
@ -388,7 +386,7 @@ void SmushPlayer::handleTextResource(Chunk & b) {
}
void SmushPlayer::readPalette(Palette & out, Chunk & in) {
unsigned char buffer[768];
byte buffer[768];
in.read(buffer, 768);
out = Palette(buffer);
}
@ -397,20 +395,20 @@ void SmushPlayer::handleDeltaPalette(Chunk & b) {
checkBlock(b, TYPE_XPAL);
debug(6, "SmushPlayer::handleDeltaPalette()");
if(b.getSize() == 768 * 3 + 4) {
int unk1, num;
int32 unk1, num;
unk1 = b.getWord();
num = b.getWord();
for(int i = 0; i < 768; i++) {
for(int32 i = 0; i < 768; i++) {
_deltaPal[i] = b.getWord();
}
readPalette(_pal, b);
updatePalette();
} else if(b.getSize() == 6) {
int unk1, num, unk2;
int32 unk1, num, unk2;
unk1 = b.getWord();
num = b.getWord();
unk2 = b.getWord();
for(int i = 0; i < 256; i++) {
for(int32 i = 0; i < 256; i++) {
_pal[i].delta(_deltaPal + 3 * i);
}
updatePalette();
@ -428,7 +426,7 @@ void SmushPlayer::handleNewPalette(Chunk & b) {
void SmushPlayer::decodeCodec(Chunk & b, const Rect & r, Decoder & codec) {
assert(_curBuffer);
Blitter blit(_curBuffer, _frameSize, r);
Blitter blit((byte*)_curBuffer, _frameSize, r);
codec.decode(blit, b);
}
@ -469,12 +467,12 @@ void SmushPlayer::handleFrameObject(Chunk & b) {
}
int codec = b.getWord();
debug(6, "SmushPlayer::handleFrameObject(%d)", codec);
unsigned short left = b.getWord();
unsigned short top = b.getWord();
unsigned short width = b.getWord();
unsigned short height = b.getWord();
uint16 left = b.getWord();
uint16 top = b.getWord();
uint16 width = b.getWord();
uint16 height = b.getWord();
Rect r(left, top, left + width, top + height);
unsigned short data[2];
uint16 data[2];
data[1] = b.getWord();
data[0] = b.getWord();
#ifdef DEBUG
@ -504,7 +502,7 @@ void SmushPlayer::handleFrameObject(Chunk & b) {
decodeCodec(b, r, _codec44);
break;
default:
error("Invalid codec for frame object : %d", (int)codec);
error("Invalid codec for frame object : %d", (int32)codec);
}
}
@ -570,7 +568,7 @@ void SmushPlayer::handleAnimHeader(Chunk & b) {
debug(6, "SmushPlayer::handleAnimHeader()");
_version = b.getWord();
_nbframes = b.getWord();
int unknown = b.getWord();
int32 unknown = b.getWord();
#ifdef DEBUG
debug(5, "SMUSH HEADER : version == %d, nbframes == %d, unknown == %d", _version, _nbframes, unknown);
#else
@ -584,11 +582,11 @@ void SmushPlayer::handleAnimHeader(Chunk & b) {
}
if(_version == 2) {
_secondaryVersion = b.getDword();
int unknown2 = b.getDword();
int32 unknown2 = b.getDword();
_soundFrequency = b.getDword();
#ifdef DEBUG
debug(5, "SMUSH HEADER : secondary version == %d, unknown2 == %d, sound frequency == %d", _secondaryVersion, unknown2, _soundFrequency);
int i = 0, c;
int32 i = 0, c;
while(!b.eof()) {
c = b.getByte();
if(c) debug(9, "SMUSH HEADER : remaining bytes : %d == %d", i, c);
@ -621,7 +619,7 @@ static StringResource * getStrings(const char * file, bool is_encoded) {
is = fopen(file, "rb");
if(is == NULL) return 0;
fseek(is, 0, SEEK_END);
int length = ftell(is);
int32 length = ftell(is);
fseek(is, 0, SEEK_SET);
char * filebuffer = new char [length + 1];
assert(filebuffer);
@ -629,7 +627,7 @@ static StringResource * getStrings(const char * file, bool is_encoded) {
filebuffer[length] = 0;
fclose(is);
if(is_encoded) {
static const int ETRS_HEADER_LENGTH = 16;
static const int32 ETRS_HEADER_LENGTH = 16;
assert(length > ETRS_HEADER_LENGTH);
Chunk::type type = READ_BE_UINT32(filebuffer);
if(type != TYPE_ETRS) {
@ -638,7 +636,7 @@ static StringResource * getStrings(const char * file, bool is_encoded) {
}
char * old = filebuffer;
filebuffer = new char[length - ETRS_HEADER_LENGTH];
for(int i = ETRS_HEADER_LENGTH; i < length; i++)
for(int32 i = ETRS_HEADER_LENGTH; i < length; i++)
filebuffer[i - ETRS_HEADER_LENGTH] = old[i] ^ 0xCC;
delete []old;
length -= ETRS_HEADER_LENGTH;
@ -737,7 +735,7 @@ bool SmushPlayer::play(const char * file) {
strcpy(file, directory); strcat(file, "titlfnt.nut");
_fr[2] = loadFont(file, true);
} else {
for(int i = 0; i < 4; i++) {
for(int32 i = 0; i < 4; i++) {
char file[260];
sprintf(file, "%s/font%d.nut",directory, i);
_fr[i] = loadFont(file, i != 0);

20
scumm/smush/player.h
View file

@ -44,13 +44,13 @@ class StringResource;
class SmushPlayer {
private:
char * _fname; //!< the name of the animation file being played
int _version; //!< the version of the animation file being played
int _secondaryVersion; //!< the secondary version number of the animation file being played
int _soundFrequency; //!< the sound frequency of the animation file being played
int _nbframes; //!< the number of frames in the animation file
int32 _version; //!< the version of the animation file being played
int32 _secondaryVersion; //!< the secondary version number of the animation file being played
int32 _soundFrequency; //!< the sound frequency of the animation file being played
int32 _nbframes; //!< the number of frames in the animation file
Mixer * _mixer; //!< the sound mixer
Palette _pal; //!< the current palette
short _deltaPal[768]; //!< the delta palette information set by an xpal
int16 _deltaPal[768]; //!< the delta palette information set by an xpal
Renderer * _renderer; //!< pointer to the ::renderer
StringResource * _strings; //!< pointer to the string resources associated with the animation
FontRenderer * _fr[4]; //!< pointers to the fonts for the animation
@ -59,7 +59,7 @@ private:
Codec44Decoder _codec44; //!< the ::decoder for codec 21 and 44
DumpDecoder _codecd; //!< the ::decoder for codec 21 and 44
Point _frameSize; //!< the current frame size of the animation
int _frame; //!< the current frame number of the animation
int32 _frame; //!< the current frame number of the animation
bool _outputSound; //!< should we handle sound ?
bool _wait; //!< should we synchronise the player ?
bool _alreadyInit; //!< has the player already been initialized for the current frame
@ -80,18 +80,18 @@ public:
protected:
bool readString(const char * file, bool &);
void clean();
void checkBlock(const Chunk &, Chunk::type, unsigned int = 0);
void checkBlock(const Chunk &, Chunk::type, uint32 = 0);
void handleAnimHeader(Chunk &);
void handleFrame(Chunk &);
void handleNewPalette(Chunk &);
void handleFrameObject(Chunk &);
void handleSoundBuffer(int, int, int, int, int, int, Chunk &, int);
void handleImuseBuffer(int, int, int, int, int, int, Chunk &, int);
void handleSoundBuffer(int32, int32, int32, int32, int32, int32, Chunk &, int32);
void handleImuseBuffer(int32, int32, int32, int32, int32, int32, Chunk &, int32);
void handleSoundFrame(Chunk &);
void handleSkip(Chunk &);
void handleStore(Chunk &);
void handleFetch(Chunk &);
void handleImuseAction8(Chunk &, int flags, int unknown, int track_id);
void handleImuseAction8(Chunk &, int32 flags, int32 unknown, int32 track_id);
void handleImuseAction(Chunk &);
void handleTextResource(Chunk &);
void handleDeltaPalette(Chunk &);

39
scumm/smush/rect.h
View file

@ -31,24 +31,24 @@
class Point {
friend class Rect;
private:
int _x; //!< The horizontal part of the point
int _y; //!< The vertical part of the point
int32 _x; //!< The horizontal part of the point
int32 _y; //!< The vertical part of the point
public:
Point() : _x(0), _y(0) {};
Point(const Point & p) : _x(p._x), _y(p._y) {};
explicit Point(int x, int y) : _x(x), _y(y) {};
explicit Point(int32 x, int32 y) : _x(x), _y(y) {};
Point & operator=(const Point & p) { _x = p._x; _y = p._y; return *this; };
bool operator==(const Point & p) const { return _x == p._x && _y == p._y; };
const int & getX() const { return _x; };
const int & getY() const { return _y; };
int & getX() { return _x; };
int & getY() { return _y; };
const int32 & getX() const { return _x; };
const int32 & getY() const { return _y; };
int32 & getX() { return _x; };
int32 & getY() { return _y; };
Point operator+(const Point & p) const { return Point(_x + p._x, _y+p._y); };
Point operator-(const Point & p) const { return Point(_x - p._x, _y-p._y); };
Point & operator+=(const Point & p) { _x += p._x; _y += p._y; return *this; };
Point & operator-=(const Point & p) { _x -= p._x; _y -= p._y; return *this; };
bool isOrigin() const { return _x == 0 && _y == 0; };
void set(int x, int y) { _x = x; _y = y; }
void set(int32 x, int32 y) { _x = x; _y = y; }
};
/*! @brief simple class for handling a rectangular zone.
@ -62,15 +62,15 @@ private:
Point _bottomRight; //!< The point at the bottom right of the rectangle
public:
Rect() : _topLeft(0, 0), _bottomRight(0,0) {}
Rect(int x, int y) : _topLeft(0, 0), _bottomRight(x, y) {}
Rect(int x1, int y1, int x2, int y2) : _topLeft(x1, y1), _bottomRight(x2, y2) {}
Rect(int32 x, int32 y) : _topLeft(0, 0), _bottomRight(x, y) {}
Rect(int32 x1, int32 y1, int32 x2, int32 y2) : _topLeft(x1, y1), _bottomRight(x2, y2) {}
Point size() const { return (_bottomRight - _topLeft); };
int width() const { return size()._x; }
int height() const { return size()._y; }
int left() const { return _topLeft._x; }
int right() const { return _bottomRight._x; }
int top() const { return _topLeft._y; }
int bottom() const { return _bottomRight._y; }
int32 width() const { return size()._x; }
int32 height() const { return size()._y; }
int32 left() const { return _topLeft._x; }
int32 right() const { return _bottomRight._x; }
int32 top() const { return _topLeft._y; }
int32 bottom() const { return _bottomRight._y; }
const Point & topLeft() const { return _topLeft; }
const Point & bottomRight() const { return _bottomRight; }
@ -81,8 +81,7 @@ public:
@return true if the given position is inside the rectangle, false otherwise
*/
bool isInside(int x, int y) const
{
bool isInside(int32 x, int32 y) const {
return (_topLeft._x <= x) && (_bottomRight._x > x) && (_topLeft._y <= y) && (_bottomRight._y > y);
}
/*! @brief check if given point is inside the rectangle
@ -91,12 +90,10 @@ public:
@return true if the given point is inside the rectangle, false otherwise
*/
bool isInside(const Point & p) const
{
bool isInside(const Point & p) const {
return (_topLeft._x <= p._x) && (_bottomRight._x > p._x) && (_topLeft._y <= p._y) && (_bottomRight._y > p._y);
}
bool clip(Rect & r) const;
};

6
scumm/smush/renderer.h
View file

@ -48,7 +48,7 @@ public:
@return true if initialisation was ok, false otherwise
*/
virtual bool startDecode(const char * fname, int version, int nbframes) = 0;
virtual bool startDecode(const char * fname, int32 version, int32 nbframes) = 0;
/*! @brief start of animation output
This is called by the animation player when the frame size is changing.
@ -75,7 +75,7 @@ public:
@return a pointer to the frame buffer to output data to.
*/
virtual char * lockFrame(int frame) = 0;
virtual char * lockFrame(int32 frame) = 0;
/*! @brief unlock a frame buffer
This is called by the animation player when a frame has been decoded.
@ -98,7 +98,7 @@ public:
@return true if everything went fine, false otherwise
*/
virtual bool wait(int ms) = 0;
virtual bool wait(int32 ms) = 0;
/*! @brief does the renderer want a premature end of the animation ?
This is called by the animation player after each frame.

66
scumm/smush/saud_channel.cpp
View file

@ -25,10 +25,10 @@
#include "chunk_type.h"
#include <assert.h>
#include <string.h> // for memcpy.h
#include <string.h>
void SaudChannel::handleStrk(Chunk & b) {
int size = b.getSize();
int32 size = b.getSize();
if(size != 14 && size != 10) {
error("STRK has a invalid size : %d", size);
}
@ -39,21 +39,21 @@ void SaudChannel::handleSmrk(Chunk & b) {
}
void SaudChannel::handleShdr(Chunk & b) {
int size = b.getSize();
int32 size = b.getSize();
if(size != 4) warning("SMRK has a invalid size : %d", size);
}
bool SaudChannel::handleSubTags(int & offset) {
bool SaudChannel::handleSubTags(int32 & offset) {
if(_tbufferSize - offset >= 8) {
Chunk::type type = READ_BE_UINT32(_tbuffer + offset);
unsigned int size = READ_BE_UINT32(_tbuffer + offset + 4);
unsigned int available_size = _tbufferSize - offset;
uint32 size = READ_BE_UINT32(_tbuffer + offset + 4);
uint32 available_size = _tbufferSize - offset;
switch(type) {
case TYPE_STRK:
_inData = false;
if(available_size >= (size + 8)) {
ContChunk c((char*)_tbuffer + offset);
ContChunk c((byte *)_tbuffer + offset);
handleStrk(c);
}
else
@ -62,7 +62,7 @@ bool SaudChannel::handleSubTags(int & offset) {
case TYPE_SMRK:
_inData = false;
if(available_size >= (size + 8)) {
ContChunk c((char*)_tbuffer + offset);
ContChunk c((byte *)_tbuffer + offset);
handleSmrk(c);
}
else
@ -71,7 +71,7 @@ bool SaudChannel::handleSubTags(int & offset) {
case TYPE_SHDR:
_inData = false;
if(available_size >= (size + 8)) {
ContChunk c((char*)_tbuffer + offset);
ContChunk c((byte *)_tbuffer + offset);
handleShdr(c);
}
else
@ -106,13 +106,13 @@ bool SaudChannel::processBuffer() {
if(_inData) {
if(_dataSize < _tbufferSize) {
// I can't assume that the channel is finished after data is received... (this assumption failed in realride.san)
int offset= _dataSize;
int32 offset = _dataSize;
while(handleSubTags(offset));
_sbufferSize = _dataSize;
_sbuffer = _tbuffer;
if(offset < _tbufferSize) { // there is still some unprocessed data
int new_size = _tbufferSize - offset;
_tbuffer = new unsigned char[new_size];
_tbuffer = new byte[new_size];
if(!_tbuffer) error("SaudChannel failed to allocate memory");
memcpy(_tbuffer, _sbuffer + offset, new_size);
_tbufferSize = new_size;
@ -133,12 +133,12 @@ bool SaudChannel::processBuffer() {
_tbuffer = 0;
}
} else {
int offset = 0;
int32 offset = 0;
while(handleSubTags(offset));
if(_inData) {
_sbufferSize = _tbufferSize - offset;
assert(_sbufferSize);
_sbuffer = new unsigned char[_sbufferSize];
_sbuffer = new byte[_sbufferSize];
if(!_sbuffer) error("saud_channel failed to allocate memory");
memcpy(_sbuffer, _tbuffer + offset, _sbufferSize);
delete []_tbuffer;
@ -147,8 +147,8 @@ bool SaudChannel::processBuffer() {
} else {
if(offset) { // maybe I should assert() this to avoid a lock...
unsigned char * old = _tbuffer;
int new_size = _tbufferSize - offset;
_tbuffer = new unsigned char[new_size];
int32 new_size = _tbufferSize - offset;
_tbuffer = new byte[new_size];
if(!_tbuffer) error("SaudChannel failed to allocate memory");
memcpy(_tbuffer, old + offset, new_size);
_tbufferSize = new_size;
@ -159,7 +159,7 @@ bool SaudChannel::processBuffer() {
return true;
}
SaudChannel::SaudChannel(int track, int freq) :
SaudChannel::SaudChannel(int32 track, int32 freq) :
_track(track),
_nbframes(0),
_dataSize(-1),
@ -186,28 +186,28 @@ bool SaudChannel::isTerminated() const {
}
void SaudChannel::recalcVolumeTable() {
const int MAX_BALANCE = 100;
int volume_left, volume_right;
const int32 MAX_BALANCE = 100;
int32 volume_left, volume_right;
if(_balance < -MAX_BALANCE || _balance > MAX_BALANCE) {
error("balance is out of range ! : %d", _balance);
}
int left_multiplier = MAX_BALANCE - _balance;
int right_multiplier = MAX_BALANCE + _balance;
int32 left_multiplier = MAX_BALANCE - _balance;
int32 right_multiplier = MAX_BALANCE + _balance;
volume_left = _volume * left_multiplier / (MAX_BALANCE * 2);
volume_right = _volume * right_multiplier / (MAX_BALANCE * 2);
if(volume_left < 0) volume_left = 0;
if(volume_left > 128) volume_left = 128;
if(volume_right < 0) volume_right = 0;
if(volume_right > 128) volume_right = 128;
for(int i = 0; i < 256; i++) {
int value = volume_left * (signed char)i;
for(int32 i = 0; i < 256; i++) {
int16 value = volume_left * (int8)i;
_voltable[0][i] = TO_BE_16(value);
value = volume_right * (signed char)i;
value = volume_right * (int8)i;
_voltable[1][i] = TO_BE_16(value);
}
}
bool SaudChannel::setParameters(int nb, int flags, int volume, int balance) {
bool SaudChannel::setParameters(int32 nb, int32 flags, int32 volume, int32 balance) {
_nbframes = nb;
_flags = flags; // bit 7 == IS_VOICE, bit 6 == IS_BACKGROUND_MUSIC, other ??
_volume = volume;
@ -217,7 +217,7 @@ bool SaudChannel::setParameters(int nb, int flags, int volume, int balance) {
return true;
}
bool SaudChannel::checkParameters(int index, int nb, int flags, int volume, int balance) {
bool SaudChannel::checkParameters(int32 index, int32 nb, int32 flags, int32 volume, int32 balance) {
if(++_index != index) error("invalid index in SaudChannel::checkParameters()");
if(_nbframes != nb) error("invalid duration in SaudChannel::checkParameters()");
if(_flags != flags) error("invalid flags in SaudChannel::checkParameters()");
@ -229,18 +229,18 @@ bool SaudChannel::checkParameters(int index, int nb, int flags, int volume, int
return true;
}
bool SaudChannel::appendData(Chunk & b, int size) {
bool SaudChannel::appendData(Chunk & b, int32 size) {
if(_dataSize == -1) { // First call
assert(size > 8);
Chunk::type saud_type = b.getDword(); saud_type = SWAP_BYTES(saud_type);
unsigned int saud_size = b.getDword(); saud_size = SWAP_BYTES(saud_size);
uint32 saud_size = b.getDword(); saud_size = SWAP_BYTES(saud_size);
if(saud_type != TYPE_SAUD) error("Invalid Chunk for SaudChannel : %X", saud_type);
size -= 8;
_dataSize = -2; // We don't get here again...
}
if(_tbuffer) {
unsigned char * old = _tbuffer;
_tbuffer = new unsigned char[_tbufferSize + size];
byte * old = _tbuffer;
_tbuffer = new byte[_tbufferSize + size];
if(!_tbuffer) error("saud_channel failed to allocate memory");
memcpy(_tbuffer, old, _tbufferSize);
delete []old;
@ -248,19 +248,19 @@ bool SaudChannel::appendData(Chunk & b, int size) {
_tbufferSize += size;
} else {
_tbufferSize = size;
_tbuffer = new unsigned char[_tbufferSize];
_tbuffer = new byte[_tbufferSize];
if(!_tbuffer) error("saud_channel failed to allocate memory");
b.read(_tbuffer, _tbufferSize);
}
return processBuffer();
}
int SaudChannel::availableSoundData(void) const {
int32 SaudChannel::availableSoundData(void) const {
return _sbufferSize;
}
void SaudChannel::getSoundData(short * snd, int size) {
for(int i = 0; i < size; i++) {
void SaudChannel::getSoundData(int16 * snd, int32 size) {
for(int32 i = 0; i < size; i++) {
snd[2 * i] = _voltable[0][_sbuffer[i] ^ 0x80];
snd[2 * i + 1] = _voltable[1][_sbuffer[i] ^ 0x80];
}

28
scumm/smush/scumm_renderer.cpp
View file

@ -41,7 +41,7 @@ public:
scumm_mixer(SoundMixer *);
virtual ~scumm_mixer();
bool init();
_Channel * findChannel(int track);
_Channel * findChannel(int32 track);
bool addChannel(_Channel * c);
bool handleFrame();
bool stop();
@ -49,7 +49,7 @@ public:
};
scumm_mixer::scumm_mixer(SoundMixer * m) : _mixer(m), _nextIndex(0) {
for(int i = 0; i < SoundMixer::NUM_CHANNELS; i++) {
for(int32 i = 0; i < SoundMixer::NUM_CHANNELS; i++) {
_channels[i].id = -1;
_channels[i].chan = 0;
_channels[i].first = true;
@ -64,9 +64,9 @@ bool scumm_mixer::init() {
return true;
}
_Channel * scumm_mixer::findChannel(int track) {
_Channel * scumm_mixer::findChannel(int32 track) {
debug(9, "scumm_mixer::findChannel(%d)", track);
for(int i = 0; i < SoundMixer::NUM_CHANNELS; i++) {
for(int32 i = 0; i < SoundMixer::NUM_CHANNELS; i++) {
if(_channels[i].id == track)
return _channels[i].chan;
}
@ -74,8 +74,8 @@ _Channel * scumm_mixer::findChannel(int track) {
}
bool scumm_mixer::addChannel(_Channel * c) {
int track = c->getTrackIdentifier();
int i;
int32 track = c->getTrackIdentifier();
int32 i;
debug(9, "scumm_mixer::addChannel(%d)", track);
@ -129,17 +129,17 @@ bool scumm_mixer::handleFrame() {
_channels[i].id = -1;
_channels[i].chan = 0;
} else {
int rate;
int32 rate;
bool stereo, is_short;
_channels[i].chan->getParameters(rate, stereo, is_short);
int size = _channels[i].chan->availableSoundData();
int32 size = _channels[i].chan->availableSoundData();
debug(9, "channel %d : %d, %s, %d bits, %d", _channels[i].id, rate, stereo ? "stereo" : "mono", is_short ? 16 : 8, size);
int flags = stereo ? SoundMixer::FLAG_STEREO : 0;
int32 flags = stereo ? SoundMixer::FLAG_STEREO : 0;
if(is_short) {
// FIXME this is one more data copy... we could get rid of it...
short * data = new short[size * (stereo ? 2 : 1)];
short * data = new int16[size * (stereo ? 2 : 1)];
_channels[i].chan->getSoundData(data, size);
size *= stereo ? 4 : 2;
@ -154,7 +154,7 @@ bool scumm_mixer::handleFrame() {
delete []data;
} else {
char * data = new char[size*(stereo ? 2 : 1)];
int8 * data = new int8[size * (stereo ? 2 : 1)];
_channels[i].chan->getSoundData(data, size);
size *= stereo ? 2 : 1;
@ -218,14 +218,14 @@ ScummRenderer::~ScummRenderer() {
_scumm->_sound->pauseBundleMusic(false);
}
bool ScummRenderer::wait(int ms) {
bool ScummRenderer::wait(int32 ms) {
while(_wait) {
_scumm->waitForTimer(1);
}
return true;
}
bool ScummRenderer::startDecode(const char * fname, int version, int nbframes) {
bool ScummRenderer::startDecode(const char * fname, int32 version, int32 nbframes) {
_scumm->_sound->pauseBundleMusic(true);
_scumm->videoFinished = 0;
_scumm->_insaneState = 1;
@ -249,7 +249,7 @@ bool ScummRenderer::setPalette(const Palette & pal) {
return BaseRenderer::setPalette(pal); // For compatibility with possible subclass...
}
void ScummRenderer::save(int frame) {
void ScummRenderer::save(int32 frame) {
int width = MIN(getWidth(), _scumm->_realWidth);
int height = MIN(getHeight(), _scumm->_realHeight);

6
scumm/smush/scumm_renderer.h
View file

@ -48,12 +48,12 @@ private:
public:
ScummRenderer(Scumm * scumm);
virtual ~ScummRenderer();
virtual bool wait(int ms);
virtual bool wait(int32 ms);
bool update();
protected:
virtual bool startDecode(const char * fname, int version, int nbframes);
virtual bool startDecode(const char * fname, int32 version, int32 nbframes);
virtual bool setPalette(const Palette & pal);
virtual void save(int frame = -1);
virtual void save(int32 frame = -1);
virtual Mixer * getMixer();
virtual bool prematureClose();
};