← Back to branch summary

~ubuntu-branches/ubuntu/raring/scummvm/raring

« back to all changes in this revision

Viewing changes to engines/gob/save/savefile.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Moritz Muehlenhoff
  • Date: 2011-05-25 19:02:23 UTC
  • mto: (21.1.2 sid)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: james.westby@ubuntu.com-20110525190223-fiqm0oaec714xk31
Tags: upstream-1.3.0
Import upstream version 1.3.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
engines/gob/save/savefile.cpp
18
18
 * along with this program; if not, write to the Free Software
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20
20
 *
21
 
 * $URL: https://scummvm.svn.sourceforge.net/svnroot/scummvm/scummvm/tags/release-1-2-1/engines/gob/save/savefile.cpp $
22
 
 * $Id: savefile.cpp 41299 2009-06-06 20:03:13Z fingolfin $
 
21
 * $URL$
 
22
 * $Id$
23
23
 *
24
24
 */
25
25
 
26
26
#include "common/util.h"
27
27
#include "common/endian.h"
 
28
#include "common/memstream.h"
28
29
#include "common/system.h"
29
30
#include "common/savefile.h"
30
31
 
84
85
        return !stream.err();
85
86
}
86
87
 
 
88
bool SaveHeader::operator==(const SaveHeader &header) const {
 
89
        return (_type    == header._type)    &&
 
90
               (_version == header._version) &&
 
91
               (_size    == header._size);
 
92
}
 
93
 
 
94
bool SaveHeader::operator!=(const SaveHeader &header) const {
 
95
        return !(*this == header);
 
96
}
 
97
 
87
98
bool SaveHeader::verifyReadSize(Common::ReadStream &stream) {
88
99
        // Compare the header with the stream's content, expect for the size
89
100
 
262
273
        return true;
263
274
}
264
275
 
265
 
SavePartSprite::SavePartSprite(uint32 width, uint32 height) {
 
276
SavePartSprite::SavePartSprite(uint32 width, uint32 height, bool trueColor) {
266
277
        assert((width > 0) && (height > 0));
267
278
 
268
279
        _width = width;
269
280
        _height = height;
270
281
 
 
282
        _oldFormat = false;
 
283
        _trueColor = trueColor;
 
284
 
271
285
        _header.setType(kID);
272
286
        _header.setVersion(kVersion);
273
 
        //            width + height +      sprite      + palette
274
 
        _header.setSize(4   +   4    + _width * _height +  768);
275
 
 
276
 
        _dataSprite  = new byte[_width * _height];
 
287
 
 
288
        _spriteSize = _width * _height;
 
289
        if (_trueColor)
 
290
                _spriteSize *= 3;
 
291
 
 
292
                //          width + height + color +    sprite   + palette
 
293
        _header.setSize(4   +   4    +   1   + _spriteSize + 768);
 
294
 
 
295
        _dataSprite  = new byte[_spriteSize];
277
296
        _dataPalette = new byte[768];
278
297
 
279
 
        memset(_dataSprite,  0, _width * _height);
 
298
        memset(_dataSprite,  0, _spriteSize);
280
299
        memset(_dataPalette, 0, 768);
281
300
}
282
301
 
286
305
}
287
306
 
288
307
bool SavePartSprite::read(Common::ReadStream &stream) {
289
 
        if (!_header.verify(stream))
290
 
                return false;
 
308
        SaveHeader header;
 
309
        header.read(stream);
 
310
 
 
311
        if (_header != header) {
 
312
                if (!_trueColor) {
 
313
                        // Header validation failed, trying again with the old version
 
314
 
 
315
                        _header.setVersion(1);
 
316
                        _header.setSize(_header.getSize() - 1);
 
317
 
 
318
                        if (_header != header)
 
319
                                // Nope, isn't it either
 
320
                                return false;
 
321
 
 
322
                        _oldFormat = true;
 
323
 
 
324
                        _header.setVersion(kVersion);
 
325
                        _header.setSize(_header.getSize() + 1);
 
326
 
 
327
                } else
 
328
                        return false;
 
329
        }
291
330
 
292
331
        // The sprite's dimensions have to fit
293
332
        if (stream.readUint32LE() != _width)
295
334
        if (stream.readUint32LE() != _height)
296
335
                return false;
297
336
 
 
337
        // If it's in the current format, the true color flag has to be the same too
 
338
        if (!_oldFormat)
 
339
                if ((stream.readByte() != 0) != _trueColor)
 
340
                        return false;
 
341
 
298
342
        // Sprite data
299
 
        if (stream.read(_dataSprite, _width * _height) != (_width * _height))
 
343
        if (stream.read(_dataSprite, _spriteSize) != _spriteSize)
300
344
                return false;
301
345
 
302
346
        // Palette data
313
357
        // The sprite's dimensions
314
358
        stream.writeUint32LE(_width);
315
359
        stream.writeUint32LE(_height);
 
360
        stream.writeByte(_trueColor);
316
361
 
317
362
        // Sprite data
318
 
        if (stream.write(_dataSprite, _width * _height) != (_width * _height))
 
363
        if (stream.write(_dataSprite, _spriteSize) != _spriteSize)
319
364
                return false;
320
365
 
321
366
        // Palette data
331
376
        return true;
332
377
}
333
378
 
334
 
bool SavePartSprite::readSprite(const SurfaceDesc &sprite) {
 
379
bool SavePartSprite::readSprite(const Surface &sprite) {
335
380
        // The sprite's dimensions have to fit
336
381
        if (((uint32)sprite.getWidth()) != _width)
337
382
                return false;
338
383
        if (((uint32)sprite.getHeight()) != _height)
339
384
                return false;
340
385
 
341
 
        memcpy(_dataSprite, sprite.getVidMem(), _width * _height);
 
386
        if (_trueColor) {
 
387
                if (sprite.getBPP() <= 1)
 
388
                        return false;
 
389
 
 
390
                Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
 
391
 
 
392
                byte *data = _dataSprite;
 
393
                ConstPixel pixel = sprite.get();
 
394
                for (uint32 i = 0; i < (_width * _height); i++, ++pixel, data += 3)
 
395
                        pixelFormat.colorToRGB(pixel.get(), data[0], data[1], data[2]);
 
396
 
 
397
        } else {
 
398
                if (sprite.getBPP() != 1)
 
399
                        return false;
 
400
 
 
401
                memcpy(_dataSprite, sprite.getData(), _width * _height);
 
402
        }
342
403
 
343
404
        return true;
344
405
}
345
406
 
346
407
bool SavePartSprite::readSpriteRaw(const byte *data, uint32 size) {
347
 
        if (size != (_width * _height))
 
408
        if (size != _spriteSize)
348
409
                return false;
349
410
 
350
411
        memcpy(_dataSprite, data, size);
357
418
        return true;
358
419
}
359
420
 
360
 
bool SavePartSprite::writeSprite(SurfaceDesc &sprite) const {
 
421
bool SavePartSprite::writeSprite(Surface &sprite) const {
361
422
        // The sprite's dimensions have to fit
362
423
        if (((uint32)sprite.getWidth()) != _width)
363
424
                return false;
364
425
        if (((uint32)sprite.getHeight()) != _height)
365
426
                return false;
366
427
 
367
 
        memcpy(sprite.getVidMem(), _dataSprite, _width * _height);
 
428
        if (_trueColor) {
 
429
                if (sprite.getBPP() <= 1)
 
430
                        return false;
 
431
 
 
432
                Graphics::PixelFormat pixelFormat = g_system->getScreenFormat();
 
433
 
 
434
                const byte *data = _dataSprite;
 
435
                Pixel pixel = sprite.get();
 
436
                for (uint32 i = 0; i < (_width * _height); i++, ++pixel, data += 3)
 
437
                        pixel.set(pixelFormat.RGBToColor(data[0], data[1], data[2]));
 
438
 
 
439
        } else {
 
440
                if (sprite.getBPP() != 1)
 
441
                        return false;
 
442
 
 
443
                memcpy(sprite.getData(), _dataSprite, _spriteSize);
 
444
        }
368
445
 
369
446
        return true;
370
447
}