[Scummvm-git-logs] scummvm master -> e8ba9d29ecdc7791be14fc686627f5a1ff9b7943

sev- noreply at scummvm.org
Fri Nov 6 20:23:05 UTC 2026


This automated email contains information about 2 new commits which have been
pushed to the 'scummvm' repo located at https://api.github.com/repos/scummvm/scummvm .

Summary:
ad1d34885f DIRECTOR: Read trailing sprite-detail offset sentinel in D6 scores
e8ba9d29ec DIRECTOR: Implement the D6-D8.5 score writer


Commit: ad1d34885f5a7d91418d513d70027a2fa1dc9748
    https://github.com/scummvm/scummvm/commit/ad1d34885f5a7d91418d513d70027a2fa1dc9748
Author: Gianluca Boiano (morf3089 at gmail.com)
Date: 2026-11-06T21:17:18+01:00

Commit Message:
DIRECTOR: Read trailing sprite-detail offset sentinel in D6 scores

The index stores numEntries+1 offsets; without the trailing sentinel
the last detail entry's length is unknown and its behavior's
initializerParams stay empty.

Fixes picked-up items reappearing in tkkg2

Changed paths:
    engines/director/score.cpp


diff --git a/engines/director/score.cpp b/engines/director/score.cpp
index a7641db0ff7..e030ed5b3ac 100644
--- a/engines/director/score.cpp
+++ b/engines/director/score.cpp
@@ -1964,11 +1964,24 @@ void Score::loadFrames(Common::SeekableReadStreamEndian &stream, uint16 version,
 			prevOff = off;
 		}
 
-		// now seek to the header, which is position 0 in the list
-		_framesStream->seek(_indexStart, SEEK_SET);
-		uint32 off = _framesStream->readUint32();
-		_framesStream->seek(_frameDataOffset + off, SEEK_SET);
-		_spriteDetailAccessed[0] = true;
+		// The index stores numEntries+1 offsets: the trailing one is an
+		// end-of-data sentinel, needed to size the last detail entry
+		if (numEntries > 0) {
+			if (listSize == numEntries + 1) {
+				uint32 endOff = _framesStream->readUint32();
+				_spriteDetailOffsets.push_back(_frameDataOffset + endOff);
+				_spriteDetailAccessed.push_back(true);
+			} else {
+				warning("Score::loadFrames(): Unexpected sprite detail list size %d for %d entries; last entry may be truncated",
+					listSize, numEntries);
+			}
+
+			// now seek to the header, which is position 0 in the list
+			_framesStream->seek(_indexStart, SEEK_SET);
+			uint32 off = _framesStream->readUint32();
+			_framesStream->seek(_frameDataOffset + off, SEEK_SET);
+			_spriteDetailAccessed[0] = true;
+		}
 	}
 
 	if (version >= kFileVer400) {


Commit: e8ba9d29ecdc7791be14fc686627f5a1ff9b7943
    https://github.com/scummvm/scummvm/commit/e8ba9d29ecdc7791be14fc686627f5a1ff9b7943
Author: Gianluca Boiano (morf3089 at gmail.com)
Date: 2026-11-06T21:17:19+01:00

Commit Message:
DIRECTOR: Implement the D6-D8.5 score writer

Fixes unloadable saved movies in tkkg7 (Score.dxr)

Changed paths:
    engines/director/archive-save.cpp
    engines/director/frame.cpp
    engines/director/score.cpp
    engines/director/score.h


diff --git a/engines/director/archive-save.cpp b/engines/director/archive-save.cpp
index e1dee6cd234..0cc83c72275 100644
--- a/engines/director/archive-save.cpp
+++ b/engines/director/archive-save.cpp
@@ -148,7 +148,17 @@ bool RIFXArchive::writeToFile(Common::String filename, Movie *movie) {
 			break;
 
 		case MKTAG('V', 'W', 'S', 'C'):
-			movie->getScore()->writeVWSCResource(saveFile, it->offset);
+			if (movie->getScore()->getVWSCResourceSize() == 0) {
+				// The serializer can't handle this score (malformed detail
+				// index or unsupported version); keep the original bytes
+				warning("STUB: RIFXArchive::writeToFile(): score not serializable; keeping the original VWSC bytes");
+				saveFile->seek(it->offset, SEEK_SET);
+				saveFile->writeUint32LE(it->tag);
+				saveFile->writeUint32LE(it->size);
+				saveFile->writeStream(getResource(it->tag, it->index));
+			} else {
+				movie->getScore()->writeVWSCResource(saveFile, it->offset);
+			}
 			break;
 
 		case MKTAG('B', 'I', 'T', 'D'):
@@ -608,6 +618,10 @@ Common::Array<Resource *> RIFXArchive::rebuildResources(Movie *movie) {
 
 		case MKTAG('V', 'W', 'S', 'C'):
 			resSize = movie->getScore()->getVWSCResourceSize();
+			if (resSize == 0) {
+				// Not serializable; the original bytes are kept (see writeToFile())
+				resSize = it->size;
+			}
 			it->size = resSize;
 			it->offset = currentSize;
 			currentSize += resSize + 8;		// The size doesn't include the header and the size entry
diff --git a/engines/director/frame.cpp b/engines/director/frame.cpp
index 8f60e12b33d..4826dbb7e9c 100644
--- a/engines/director/frame.cpp
+++ b/engines/director/frame.cpp
@@ -1348,7 +1348,7 @@ static void writePadding(Common::SeekableWriteStream *writeStream, int size) {
 
 void Frame::writeMainChannelsD6(Common::SeekableWriteStream *writeStream) {
 	// Script
-	writeStream->writeUint32BE(_mainChannels.actionId.castLib);				// 0+0
+	writeStream->writeUint16BE(_mainChannels.actionId.castLib);				// 0+0
 	writeStream->writeUint16BE(_mainChannels.actionId.member);				// 0+2
 	writeStream->writeUint32BE(_mainChannels.scriptSpriteListIdx);			// 0+4
 	writeStream->writeByte(_mainChannels.colorScript);						// 0+8
@@ -1799,7 +1799,7 @@ void Frame::readMainChannelsD7(Common::MemoryReadStreamEndian &stream, uint16 of
 
 void Frame::writeMainChannelsD7(Common::SeekableWriteStream *writeStream) {
 	// Script
-	writeStream->writeUint32BE(_mainChannels.actionId.castLib);				// 0+0
+	writeStream->writeUint16BE(_mainChannels.actionId.castLib);				// 0+0
 	writeStream->writeUint16BE(_mainChannels.actionId.member);				// 0+2
 	writeStream->writeUint32BE(_mainChannels.scriptSpriteListIdx);			// 0+4
 	writeStream->writeByte(_mainChannels.colorScript);						// 0+8
diff --git a/engines/director/score.cpp b/engines/director/score.cpp
index e030ed5b3ac..81eea3257b6 100644
--- a/engines/director/score.cpp
+++ b/engines/director/score.cpp
@@ -1930,7 +1930,8 @@ void Score::loadFrames(Common::SeekableReadStreamEndian &stream, uint16 version,
 		_firstFramePosition = _framesStream->pos();
 	} else if (version >= kFileVer600) {
 		_framesStreamSize = _framesStream->readUint32();
-		int32 ver = (int32)_framesStream->readUint32();
+		_scoreWrapperVer = (int32)_framesStream->readUint32();
+		int32 ver = _scoreWrapperVer;
 		uint32 listStart = _framesStream->readUint32();
 
 		debugC(1, kDebugLoading, "Score::loadFrames(): D6+ len: %d, version: %d, listStart: 0x%x",
@@ -1971,6 +1972,7 @@ void Score::loadFrames(Common::SeekableReadStreamEndian &stream, uint16 version,
 				uint32 endOff = _framesStream->readUint32();
 				_spriteDetailOffsets.push_back(_frameDataOffset + endOff);
 				_spriteDetailAccessed.push_back(true);
+				_spriteDetailIndexValid = true;
 			} else {
 				warning("Score::loadFrames(): Unexpected sprite detail list size %d for %d entries; last entry may be truncated",
 					listSize, numEntries);
@@ -2516,6 +2518,143 @@ Common::String Score::formatChannelInfo() {
 
 }
 
+// Serializes the D6+ VWSC wrapper: 12-byte header, sprite-detail offset
+// index, entry 0 (the frames stream, re-serialized as one full frame
+// followed by channel deltas) and the remaining detail entries copied
+// from the retained stream. Returns false when the loaded index isn't
+// usable (the caller then keeps the original bytes).
+bool Score::buildD6Score(Common::MemoryWriteStreamDynamic &out) {
+	// The detail offsets include the trailing end-of-data sentinel
+	if (!_framesStream || !_spriteDetailIndexValid || _spriteDetailOffsets.size() < 2 || _scoreCache.empty())
+		return false;
+
+	// Validate the retained offsets: monotonic and within the stream
+	for (uint i = 1; i < _spriteDetailOffsets.size(); i++)
+		if (_spriteDetailOffsets[i] < _spriteDetailOffsets[i - 1] || _spriteDetailOffsets[i] > (uint32)_framesStream->size())
+			return false;
+
+	uint32 channelSize, mainChannelSize;
+	if (_version >= kFileVer600 && _version < kFileVer700) {
+		channelSize = kSprChannelSizeD6;
+		mainChannelSize = kMainChannelSizeD6;
+	} else if (_version >= kFileVer700 && _version < kFileVer1000) {
+		channelSize = kSprChannelSizeD7;
+		mainChannelSize = kMainChannelSizeD7;
+	} else {
+		return false;
+	}
+
+	uint32 numEntries = _spriteDetailOffsets.size() - 1;
+
+	// Serialize each frame's channels; emit a full first frame, then only
+	// the channels that changed (the chunk format readOneFrame() consumes)
+	Common::MemoryWriteStreamDynamic frames(DisposeAfterUse::YES);
+	Common::Array<byte> prev;
+	for (uint f = 0; f < _scoreCache.size(); f++) {
+		Frame &frame = *_scoreCache[f];
+		uint numSprites = frame._sprites.size();
+
+		// Serialize the frame's whole channel buffer
+		Common::MemoryWriteStreamDynamic cur(DisposeAfterUse::YES);
+		frame.writeMainChannels(&cur, _version);
+		for (uint ch = 1; ch < numSprites; ch++) {
+			if (_version < kFileVer700)
+				writeSpriteDataD6(&cur, *frame._sprites[ch]);
+			else
+				writeSpriteDataD7(&cur, *frame._sprites[ch]);
+		}
+
+		// The chunk offsets below assume exactly this layout; a mismatch
+		// means a channel writer is out of sync with its reader
+		if ((uint32)cur.size() != mainChannelSize + (numSprites - 1) * channelSize) {
+			warning("Score::buildD6Score(): channel buffer is %d bytes, expected %d; falling back",
+				(int)cur.size(), mainChannelSize + (numSprites - 1) * channelSize);
+			return false;
+		}
+
+		// Collect the chunks that differ from the previous frame
+		struct Chunk { uint32 offset, size; };
+		Common::Array<Chunk> chunks;
+		const byte *data = cur.getData();
+		if (prev.empty()) {
+			chunks.push_back({0, (uint32)cur.size()});
+		} else {
+			for (uint ch = 0; ch < numSprites; ch++) {
+				uint32 off = ch ? mainChannelSize + (ch - 1) * channelSize : 0;
+				uint32 size = ch ? channelSize : mainChannelSize;
+				if (off + size > (uint32)cur.size() || off + size > prev.size() ||
+						memcmp(data + off, prev.data() + off, size))
+					chunks.push_back({off, size});
+			}
+		}
+
+		uint32 frameSize = 2;
+		for (auto &c : chunks)
+			frameSize += 4 + c.size;
+		// All the on-disk fields are 16-bit
+		if (frameSize > 0xFFFF || (chunks.size() && chunks[chunks.size() - 1].offset > 0xFFFF))
+			return false;
+		frames.writeUint16BE(frameSize);
+		for (auto &c : chunks) {
+			frames.writeUint16BE(c.size);
+			frames.writeUint16BE(c.offset);
+			frames.write(data + c.offset, c.size);
+		}
+
+		prev.resize(cur.size());
+		memcpy(prev.data(), data, cur.size());
+	}
+
+	// entry 0 = 20-byte frames header + the frame data
+	uint32 entry0Size = 20 + frames.size();
+
+	Common::Array<uint32> offsets(numEntries + 1);
+	offsets[0] = 0;
+	offsets[1] = entry0Size;
+	for (uint i = 1; i < numEntries; i++)
+		offsets[i + 1] = offsets[i] + (_spriteDetailOffsets[i + 1] - _spriteDetailOffsets[i]);
+
+	uint32 dataLen = offsets[numEntries];
+	uint32 total = 12 + 12 + (numEntries + 1) * 4 + dataLen;
+
+	out.writeUint32BE(total);
+	out.writeSint32BE(_scoreWrapperVer);
+	out.writeUint32BE(12);					// the index follows this header
+
+	out.writeSint32BE(numEntries);
+	out.writeSint32BE(numEntries + 1);
+	out.writeUint32BE(dataLen);
+	for (uint i = 0; i <= numEntries; i++)
+		out.writeUint32BE(offsets[i]);
+
+	out.writeUint32BE(entry0Size);
+	out.writeSint32BE(20);					// frame data follows this header
+	out.writeUint32BE(_scoreCache.size());	// the loader recomputes this anyway
+	out.writeUint16BE(_framesVersion);
+	out.writeUint16BE(_spriteRecordSize);
+	out.writeUint16BE(_numChannels);
+	out.writeUint16BE(_numChannelsDisplayed);
+	out.write(frames.getData(), frames.size());
+
+	// The remaining detail entries (sprite info, behaviors, names) can't
+	// change at runtime; copy them from the retained stream
+	for (uint i = 1; i < numEntries; i++) {
+		uint32 size = _spriteDetailOffsets[i + 1] - _spriteDetailOffsets[i];
+		if (!size)
+			continue;
+		byte *buf = (byte *)malloc(size);
+		_framesStream->seek(_spriteDetailOffsets[i], SEEK_SET);
+		if (_framesStream->read(buf, size) != size) {
+			free(buf);
+			return false;
+		}
+		out.write(buf, size);
+		free(buf);
+	}
+
+	return true;
+}
+
 void Score::writeVWSCResource(Common::SeekableWriteStream *writeStream, uint32 offset) {
 	uint32 channelSize = 0;
 	uint32 mainChannelSize = 0;
@@ -2525,12 +2664,17 @@ void Score::writeVWSCResource(Common::SeekableWriteStream *writeStream, uint32 o
 	} else if (_version >= kFileVer500 && _version < kFileVer600) {
 		channelSize = kSprChannelSizeD5;
 		mainChannelSize = kMainChannelSizeD5;
-	} else if (_version >= kFileVer600 && _version < kFileVer700) {
-		channelSize = kSprChannelSizeD6;
-		mainChannelSize = kMainChannelSizeD6;
-	} else if (_version >= kFileVer700 && _version < kFileVer1100) {
-		channelSize = kSprChannelSizeD7;
-		mainChannelSize = kMainChannelSizeD7;
+	} else if (_version >= kFileVer600 && _version < kFileVer1000) {
+		Common::MemoryWriteStreamDynamic buf(DisposeAfterUse::YES);
+		if (!buildD6Score(buf)) {
+			warning("Score::writeVWSCResource: Could not serialize the D6+ score");
+			return;
+		}
+		writeStream->seek(offset);
+		writeStream->writeUint32LE(MKTAG('V', 'W', 'S', 'C'));
+		writeStream->writeUint32LE(buf.size());
+		writeStream->write(buf.getData(), buf.size());
+		return;
 	} else {
 		warning("Score::writeVWSCResource: Writing this Director version is not supported yet");
 		return;
@@ -2594,7 +2738,7 @@ void Score::writeFrame(Common::SeekableWriteStream *writeStream, Frame frame, ui
 			writeSpriteDataD5(writeStream, sprite);
 		} else if (_version >= kFileVer600 && _version < kFileVer700) {
 			writeSpriteDataD6(writeStream, sprite);
-		} else if (_version >= kFileVer700 && _version < kFileVer1100) {
+		} else if (_version >= kFileVer700 && _version < kFileVer1000) {
 			writeSpriteDataD7(writeStream, sprite);
 		}
 	}
@@ -2609,15 +2753,14 @@ uint32 Score::getVWSCResourceSize() {
 	} else if (_version >= kFileVer500 && _version < kFileVer600) {
 		channelSize = kSprChannelSizeD5;
 		mainChannelSize = kMainChannelSizeD5;
-	} else if (_version >= kFileVer600 && _version < kFileVer700) {
-		// Must match writeVWSCResource()/Frame::readChannel() (D6: main channel 144).
-		channelSize = kSprChannelSizeD6;
-		mainChannelSize = kMainChannelSizeD6;
-	} else if (_version >= kFileVer700 && _version < kFileVer1100) {
-		channelSize = kSprChannelSizeD7;
-		mainChannelSize = kMainChannelSizeD7;
+	} else if (_version >= kFileVer600 && _version < kFileVer1000) {
+		Common::MemoryWriteStreamDynamic buf(DisposeAfterUse::YES);
+		if (!buildD6Score(buf))
+			return 0;	// keep the original bytes
+		return buf.size();
 	} else {
 		warning("Score::getVWSCResourceSize: Director version unsupported");
+		return 0;
 	}
 
 	uint32 framesSize = 0;
diff --git a/engines/director/score.h b/engines/director/score.h
index 413ac7efb8d..efd7c30a1b0 100644
--- a/engines/director/score.h
+++ b/engines/director/score.h
@@ -37,6 +37,7 @@ namespace Common {
 	class MemoryReadStreamEndian;
 	class SeekableReadStreamEndian;
 	class SeekableWriteStream;
+	class MemoryWriteStreamDynamic;
 }
 
 namespace Director {
@@ -78,6 +79,7 @@ public:
 
 	void writeVWSCResource(Common::SeekableWriteStream *writeStream, uint32 offset);
 	uint32 getVWSCResourceSize();
+	bool buildD6Score(Common::MemoryWriteStreamDynamic &out);
 
 	void loadLabels(Common::SeekableReadStreamEndian &stream);
 	void loadActions(Common::SeekableReadStreamEndian &stream);
@@ -198,7 +200,8 @@ public:
 	uint16 _spriteRecordSize;
 	uint16 _numChannels;
 	int16 _numChannelsDisplayed;  // D7+, no-op in earlier versions
-	//  20 bytes in total
+	int32 _scoreWrapperVer = 0;	// D6+ wrapper header version (e.g. -3)
+	bool _spriteDetailIndexValid = false;	// D6+ index had the trailing sentinel
 
 	int16 _maxChannelsUsed; // max channel number used in the score, used to optimize rendering
 




More information about the Scummvm-git-logs mailing list