CSNG (File Format) - Revision history

imported>Jackoalan: /* Region Info */

2018-09-04T05:32:27Z

Region Info

← Older revision		Revision as of 05:32, 4 September 2018
Line 104:		Line 104:
	\| 0x8		\| 0x8
	\| 2		\| 2
	\| '''Region Data Index'''; used to select region data ~~via the ''region data index~~''~~; value is negative on a dummy~~ ''region ~~info~~'~~' to terminate track regions~~		\| '''Region Data Index'''; used to select region data when positive; -1 value terminates track; -2 value loops jumps to ''Loop Region Index'' at this region's tick
	\|-		\|-
	\| 0xA		\| 0xA
	\| 2		\| 2
	~~\| {{unknown~~\|'''~~Unknown~~'''}}		\| '''Loop Region Index'''; index of region to jump to if ''Region Data Index'' set to -2
	\|-		\|-
	\| 0xC		\| 0xC

imported>Jackoalan: /* Continuous Pitch / Modulation Data */

2018-08-16T21:08:13Z

Continuous Pitch / Modulation Data

← Older revision		Revision as of 21:08, 16 August 2018
Line 266:		Line 266:
	(0x80). The decoder must track the absolute time and value, summing each consecutive update		(0x80). The decoder must track the absolute time and value, summing each consecutive update
	for the current time/values.		for the current time/values.

			The byte sequence 0x80 0x00 is a special case that signals the end of the stream.

	Similar to the command stream, when the delta time exceeds 15 bit range (>32767), extra pairs		Similar to the command stream, when the delta time exceeds 15 bit range (>32767), extra pairs
Line 296:		Line 298:
	ret = [0,0]		ret = [0,0]
	while ret[1] == 0:		while ret[1] == 0:
			if streamIn.PeekU16() == 0x8000:
			# The stream has ended
			break
	ret[0] += DecodeUnsignedValue(streamIn)		ret[0] += DecodeUnsignedValue(streamIn)
	ret[1] = DecodeSignedValue(streamIn)		ret[1] = DecodeSignedValue(streamIn)

imported>Jackoalan: /* Delta Time RLE */

2018-08-16T20:36:07Z

Delta Time RLE

← Older revision		Revision as of 20:36, 16 August 2018
Line 147:		Line 147:
	in SNG: ''note'', ''control change'', and ''program change''.		in SNG: ''note'', ''control change'', and ''program change''.

	=====Delta Time ~~RLE~~=====		=====Delta Time Encoding=====

	Just like MIDI, each command starts with a '''delta time''' value telling the sequencer		Just like MIDI, each command starts with a '''delta time''' value telling the sequencer

imported>Jackoalan: /* Continuous Pitch / Modulation Data */

2018-08-16T20:31:45Z

Continuous Pitch / Modulation Data

← Older revision		Revision as of 20:31, 16 August 2018
Line 268:		Line 268:

	Similar to the command stream, when the delta time exceeds 15 bit range (>32767), extra pairs		Similar to the command stream, when the delta time exceeds 15 bit range (>32767), extra pairs
	with a value delta are inserted.		with a zeroed value delta are inserted.

	<syntaxhighlight lang="python" line="1">		<syntaxhighlight lang="python" line="1">

imported>Jackoalan: Fix pitch/mod encoding scheme

2018-08-16T20:30:01Z

Fix pitch/mod encoding scheme

← Older revision		Revision as of 20:30, 16 August 2018
Line 163:		Line 163:
	next = streamIn.PeekU16()		next = streamIn.PeekU16()
	if next == 0:		if next == 0:
			# Automatically consume no-op and continue accumulating time value
	total += 0xffff		total += 0xffff
	streamIn.seekAhead(2)		streamIn.seekAhead(2)
Line 169:		Line 170:
	return total		return total
	</syntaxhighlight>		</syntaxhighlight>

			=====No-Op Command=====

			When the two bytes following the delta-time are both zero, this is a no-op command.

			As mentioned before, no-ops are useful for accumulating delta times greater than 65535.

	=====Note Command=====		=====Note Command=====
Line 253:		Line 260:
	====Continuous Pitch / Modulation Data====		====Continuous Pitch / Modulation Data====

	If the pitch or mod offsets in a region are non-zero, they point to a buffer of ~~RLE-compressed~~		If the pitch or mod offsets in a region are non-zero, they point to a buffer of
	(delta-tick, delta-value) pairs~~, decoding~~ to ~~signed 16~~-bit ~~precision~~. The decoder must track		(delta-tick, delta-value) pairs. The delta times are encoded as unsigned 7/15 bit values
	the absolute time and value, summing each consecutive update for the current time/values.		and the delta values are signed 7/15-bit values. The values are promoted to 15-bit if they
			exceed their 7-bit range. In this case, the highest bit is set on the first byte in the pair
			(0x80). The decoder must track the absolute time and value, summing each consecutive update
			for the current time/values.

	~~The algorithm for this RLE is different than~~ the delta-time ~~one for commands. It may~~		Similar to the command stream, when the delta time exceeds 15 bit range (>32767), extra pairs
	~~scale down to~~ a ~~single byte if able~~.		with a value delta are inserted.

	<syntaxhighlight lang="python" line="1">		<syntaxhighlight lang="python" line="1">
	def ~~DecodeRLE~~(~~streamIn~~):		def SignExtend7(value):
	~~# high~~-~~bit shift-trigger RLE, limited to 2 bytes~~		return (value & 0x3f) - (value & 0x40)
	~~term = streamIn.ReadU8~~()
	~~total = term & 0x7f~~		def SignExtend15(value):
	~~if term & 0x80:~~		return (value & 0x3fff) - (value & 0x4000)
	~~total = total * 256 + streamIn.ReadU8~~()
	return ~~total~~

	def ~~DecodeContinuousRLE~~(streamIn~~, isValue~~):		def DecodeSignedValue(streamIn):
	~~total~~ = 0		byte0 = streamIn.ReadU8()
	~~while True~~:		if byte0 & 0x80:
	~~# 1-2 byte RLE accumulated within continuable RLE~~		byte1 = streamIn.ReadU8()
	~~term~~ = ~~DecodeRLE~~(~~streamIn~~)		return SignExtend15(byte1 \| ((byte0 & 0x7f) << 8))
	~~if term == 0x8000:~~		else:
	~~total += 0xffff~~		return SignExtend7(byte0)
	~~dummy = streamIn.ReadU8~~()
	~~continue~~
	~~total += term~~

	~~# values are signed deltas;~~		def DecodeUnsignedValue(streamIn):
	~~# extending into the high-half of 15-bit precision~~		byte0 = streamIn.ReadU8()
	if ~~isValue~~:		if byte0 & 0x80:
	~~if total >~~= ~~0x4000:~~		byte1 = streamIn.ReadU8()
	return ~~total - 0xffff~~		return byte1 \| ((byte0 & 0x7f) << 8)
	else:		else:
	return ~~total~~		return byte0

	~~# times are always forward-deltas~~		def DecodeDeltaPair(streamIn):
	return ~~total~~		ret = [0,0]
			while ret[1] == 0:
			ret[0] += DecodeUnsignedValue(streamIn)
			ret[1] = DecodeSignedValue(streamIn)
			return ret
	</syntaxhighlight>		</syntaxhighlight>

imported>Jackoalan: Clarify nature of delta time encoding

2018-08-16T20:04:55Z

Clarify nature of delta time encoding

← Older revision		Revision as of 20:04, 16 August 2018
Line 150:		Line 150:

	Just like MIDI, each command starts with a '''delta time''' value telling the sequencer		Just like MIDI, each command starts with a '''delta time''' value telling the sequencer
	how many ticks to wait after the previous command. Unlike MIDI, Factor5 uses a ~~custom~~		how many ticks to wait after the previous command. Unlike MIDI, Factor5 uses a fixed 16-bit
	~~[[wikipedia:Run-length encoding\|RLE scheme]]~~ to ~~adaptively scale~~ the ~~value's precision~~		value to store the delta times. In case of a delta time greater than 65535, no-op commands
	~~to reduce~~ the ~~value's size~~.		with a 65535 delta time are inserted into the command stream until the target time is attained.

	~~The RLE operates on 16-bit words, with the value 0xffff triggering~~ a ~~continuation,~~		In a theoretical Python streaming API, the delta time can be decoded with no-ops automatically consumed like so:
	~~then a 'dead' 16-bit word skipped over~~, ~~then~~ the ~~0xffff is summed~~ with ~~the following RLE value,~~
	~~looping the decode algorithm.~~

	~~In Python, decoding works~~ like so:

	<syntaxhighlight lang="python" line="1">		<syntaxhighlight lang="python" line="1">
	def ~~DecodeDeltaTimeRLE~~(streamIn):		def DecodeDeltaTime(streamIn):
	total = 0		total = 0
	while True:		while True:
	term = streamIn.ReadU16()		term = streamIn.ReadU16()
	if ~~term~~ == ~~0xffff~~:		next = streamIn.PeekU16()
			if next == 0:
	total += 0xffff		total += 0xffff
	~~dummy =~~ streamIn.~~ReadU16~~()		streamIn.seekAhead(2)
	continue		continue
	total += term		total += term

imported>Jackoalan: /* Region Data */

2016-06-22T03:57:25Z

Region Data

← Older revision		Revision as of 03:57, 22 June 2016
Line 144:		Line 144:
	====Region Commands====		====Region Commands====

	After the region data header, the actual playback commands begin. There are only 2 types of commands		After the region data header, the actual playback commands begin. There are only 3 types of commands
	in SNG: ''note'' and ''~~control~~ change''.		in SNG: ''note'', ''control change'', and ''program change''.

	=====Delta Time RLE=====		=====Delta Time RLE=====
Line 175:		Line 175:
	=====Note Command=====		=====Note Command=====

	When the two bytes following the delta-time != 0xffff, and the high-~~bit~~ of ~~the first byte is~~ ''unset'',		When the two bytes following the delta-time != 0xffff, and the high-bits of both bytes are ''unset'',
	this is a '''note command'''.		this is a '''note command'''.

Line 204:		Line 204:
	=====Control Change Command=====		=====Control Change Command=====

	When the two bytes following the delta-time != 0xffff, and the high-~~bit~~ of ~~the first byte is~~ ''set'',		When the two bytes following the delta-time != 0xffff, and the high-bits of both bytes are ''set'',
	this is a '''control change command'''.		this is a '''control change command'''.

Line 224:		Line 224:
	\| 0x2		\| 0x2
	\| colspan=2 {{unknown\|End of control change}}		\| colspan=2 {{unknown\|End of control change}}
			\|}

			=====Program Change Command=====

			When the two bytes following the delta-time != 0xffff, and the high-bit of the first byte is ''set'',
			this is a '''program change command'''.

			See the [https://www.midi.org/specifications/item/gm-level-1-sound-set standard MIDI program numbers] for details.

			{\| class="wikitable"
			! Offset
			! Size
			! Description
			\|-
			\| 0x0
			\| 1
			\| '''Program'''; AND with 0x7f for the value
			\|-
			\| 0x1
			\| 1
			\| '''Padding'''; always zero
			\|-
			\| 0x2
			\| colspan=2 {{unknown\|End of program change}}
	\|}		\|}

imported>Jackoalan: Multi-track SNG clarifications

2016-06-20T20:13:18Z

Multi-track SNG clarifications

Show changes

imported>Jackoalan: /* Continuous Pitch / Modulation Data */

2016-05-20T00:31:12Z

Continuous Pitch / Modulation Data

← Older revision		Revision as of 00:31, 20 May 2016
Line 264:		Line 264:
	if term == 0x8000:		if term == 0x8000:
	total += 0xffff		total += 0xffff
	dummy = in.ReadU8()		dummy = streamIn.ReadU8()
	continue		continue
	total += term		total += term

imported>Jackoalan at 00:30, 20 May 2016

2016-05-20T00:30:59Z

← Older revision		Revision as of 00:30, 20 May 2016
Line 170:		Line 170:

	<syntaxhighlight lang="python" line="1">		<syntaxhighlight lang="python" line="1">
	def DecodeDeltaTimeRLE(in):		def DecodeDeltaTimeRLE(streamIn):
	total = 0		total = 0
	while True:		while True:
	term = in.ReadU16()		term = streamIn.ReadU16()
	if term == 0xffff:		if term == 0xffff:
	total += 0xffff		total += 0xffff
	dummy = in.ReadU16()		dummy = streamIn.ReadU16()
	continue		continue
	total += term		total += term
Line 249:		Line 249:

	<syntaxhighlight lang="python" line="1">		<syntaxhighlight lang="python" line="1">
	def DecodeRLE(in):		def DecodeRLE(streamIn):
	# high-bit shift-trigger RLE, limited to 2 bytes		# high-bit shift-trigger RLE, limited to 2 bytes
	term = in.ReadU8()		term = streamIn.ReadU8()
	total = term & 0x7f		total = term & 0x7f
	if term & 0x80:		if term & 0x80:
	total = total * 256 + in.ReadU8()		total = total * 256 + streamIn.ReadU8()
	return total		return total

	def DecodeContinuousRLE(in, isValue):		def DecodeContinuousRLE(streamIn, isValue):
	total = 0		total = 0
	while True:		while True:
	# 1-2 byte RLE accumulated within continuable RLE		# 1-2 byte RLE accumulated within continuable RLE
	term = DecodeRLE(in)		term = DecodeRLE(streamIn)
	if term == 0x8000:		if term == 0x8000:
	total += 0xffff		total += 0xffff