//Constructors
public ByteBuffer()
{
stream = new MemoryStream();
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream);
reader = new EndianBinaryReader(bitConverter, stream);
}
/// <summary>
/// Constructs a new binary reader with the given bit converter, reading
/// to the given stream, using the given encoding.
/// </summary>
/// <param name="bitConverter">Converter to use when reading data</param>
/// <param name="stream">Stream to read data from</param>
/// <param name="encoding">Encoding to use when reading character data</param>
public EndianBinaryReader(EndianBitConverter bitConverter, Stream stream, Encoding encoding)
{
if (bitConverter == null)
{
throw new ArgumentNullException("bitConverter");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (encoding == null)
{
throw new ArgumentNullException("encoding");
}
if (!stream.CanRead)
{
throw new ArgumentException("Stream isn't writable", "stream");
}
this.stream = stream;
this.bitConverter = bitConverter;
this.encoding = encoding;
this.decoder = encoding.GetDecoder();
this.minBytesPerChar = 1;
if (encoding is UnicodeEncoding)
{
minBytesPerChar = 2;
}
}
public EndianBinaryReader(EndianBitConverter bitConverter, Stream stream, System.Text.Encoding encoding)
{
this.disposed = false;
this.buffer = new byte[0x10];
this.charBuffer = new char[1];
if (bitConverter == null)
{
throw new ArgumentNullException("bitConverter");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (encoding == null)
{
throw new ArgumentNullException("encoding");
}
if (!stream.CanRead)
{
throw new ArgumentException("Stream isn't writable", "stream");
}
this.stream = stream;
this.bitConverter = bitConverter;
this.encoding = encoding;
this.decoder = encoding.GetDecoder();
this.minBytesPerChar = 1;
if (encoding is UnicodeEncoding)
{
this.minBytesPerChar = 2;
}
}
public EndianBinaryWriter(EndianBitConverter bitConverter, Stream stream, System.Text.Encoding encoding)
{
this.disposed = false;
this.buffer = new byte[0x10];
this.charBuffer = new char[1];
if (bitConverter == null)
{
throw new ArgumentNullException("bitConverter");
}
if (stream == null)
{
throw new ArgumentNullException("stream");
}
if (encoding == null)
{
throw new ArgumentNullException("encoding");
}
if (!stream.CanWrite)
{
throw new ArgumentException("Stream isn't writable", "stream");
}
this.stream = stream;
this.bitConverter = bitConverter;
this.encoding = encoding;
}
public ByteBuffer(int capacity)
{
stream = new MemoryStream();
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream);
reader = new EndianBinaryReader(bitConverter, stream);
stream.Capacity = capacity;
}
public ByteBuffer(Endianness _endianess, System.Text.Encoding _encoding)
{
stream = new MemoryStream();
if (_endianess == Endianness.BigEndian)
bitConverter = new BigEndianBitConverter();
else
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream, _encoding);
reader = new EndianBinaryReader(bitConverter, stream, _encoding);
}
public ByteBuffer(int capacity, int position, MemoryStream _stream)
{
stream = new MemoryStream();
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream);
reader = new EndianBinaryReader(bitConverter, stream);
stream.Capacity = capacity;
stream.Position = position;
stream = _stream;
}
public ByteBuffer(Endianness _endianess, System.Text.Encoding _encoding, int capacity, int position, MemoryStream _stream)
{
stream = new MemoryStream();
if (_endianess == Endianness.BigEndian)
bitConverter = new BigEndianBitConverter();
else
bitConverter = new LittleEndianBitConverter();
writer = new EndianBinaryWriter(bitConverter, stream, _encoding);
reader = new EndianBinaryReader(bitConverter, stream, _encoding);
stream.Capacity = capacity;
stream.Position = position;
stream = _stream;
}
/// <summary>
/// Constructs a new binary writer with the given bit converter, writing
/// to the given stream, using the given encoding.
/// </summary>
/// <param name="bitConverter">Converter to use when writing data</param>
/// <param name="stream">Stream to write data to</param>
/// <param name="encoding">Encoding to use when writing character data</param>
public EndianBinaryWriter(EndianBitConverter bitConverter, Stream stream, Encoding encoding)
{
if (bitConverter == null)
throw new ArgumentNullException("bitConverter");
if (stream == null)
throw new ArgumentNullException("stream");
if (encoding == null)
throw new ArgumentNullException("encoding");
if (!stream.CanWrite)
throw new ArgumentException("Stream isn't writable", "stream");
this.stream = stream;
this.bitConverter = bitConverter;
this.encoding = encoding;
}
private ByteOrder(string endianess)
{
ByteOrder_Endianess = endianess;
if (ByteOrder_Endianess == "BIG_ENDIAN")
bitConverter = new BigEndianBitConverter();
else
bitConverter = new LittleEndianBitConverter();
}
public ByteBuffer Order(ByteOrder _byteorder)
{
byteorder = _byteorder;
if (byteorder == ByteOrder.BIG_ENDIAN)
bitConverter = new BigEndianBitConverter();
else
bitConverter = new LittleEndianBitConverter();
return this;
}
// COMPLETE
private static void WriteRocksmithSngFile(Song rocksmithSong, InstrumentTuning tuning, ArrangementType arrangementType, string outputFile, EndianBitConverter bitConverter)
{
var iterationInfo = CreatePhraseIterationInfo(rocksmithSong);
// WRITE THE .SNG FILE
using (FileStream fs = new FileStream(outputFile, FileMode.Create))
using (EndianBinaryWriter w = new EndianBinaryWriter(bitConverter, fs))
{
// HEADER
WriteRocksmithSngHeader(w, arrangementType);
// EBEATS DATA
WriteRocksmithSngEbeats(w, rocksmithSong.Ebeats);
// PHRASES
WriteRocksmithSngPhrases(w, rocksmithSong.Phrases, rocksmithSong.PhraseIterations);
// CHORD TEMPLATES
WriteRocksmithSngChordTemplates(w, rocksmithSong.ChordTemplates, tuning, arrangementType);
// FRET HAND MUTE TEMPLATE
WriteRocksmithSngFretHandMuteTemplates(w, rocksmithSong.FretHandMuteTemplates);
// VOCALS TEMPLATE
w.Write(new byte[4]); // not used on song file
// PHRASE ITERATIONS
WriteRocksmithSngPhraseIterations(w, rocksmithSong.PhraseIterations, rocksmithSong.SongLength);
// PHRASE PROPERTIES
WriteRocksmithSngPhraseProperties(w, rocksmithSong.PhraseProperties);
// LINKED DIFFS
WriteRocksmithSngLinkedDiffs(w, rocksmithSong.LinkedDiffs);
// CONTROLS
WriteRocksmithSngControls(w, rocksmithSong.Controls);
// EVENTS
WriteRocksmithSngEvents(w, rocksmithSong.Events);
// SECTIONS
WriteRocksmithSngSections(w, rocksmithSong.Sections, rocksmithSong.PhraseIterations, rocksmithSong.SongLength);
// LEVELS
WriteRocksmithSngLevels(w, rocksmithSong.Levels, rocksmithSong.SongLength, iterationInfo, arrangementType);
// SONG META DATA
WriteRocksmithSngMetaDetails(w, rocksmithSong, tuning, iterationInfo);
}
}
// COMPLETE
private static void WriteRocksmithVocalsFile(Vocals vocals, string outputFile, EndianBitConverter bitConverter)
{
// WRITE THE .SNG FILE
using (FileStream fs = new FileStream(outputFile, FileMode.Create))
using (EndianBinaryWriter w = new EndianBinaryWriter(bitConverter, fs))
{
// file header
WriteRocksmithSngHeader(w, ArrangementType.Vocal);
// unused filler
w.Write(new byte[16]);
// vocal count
if (vocals.Count != vocals.Vocal.Length)
throw new InvalidDataException("XML vocals header count does not match number of vocal items.");
w.Write(vocals.Count);
// vocals
for (int i = 0; i < vocals.Vocal.Length; i++)
{
// vocal time
w.Write(vocals.Vocal[i].Time);
// vocal note
w.Write(vocals.Vocal[i].Note);
// vocal length
w.Write(vocals.Vocal[i].Length);
// vocal lyric
string lyric = vocals.Vocal[i].Lyric;
if (lyric.Length > 32)
throw new InvalidDataException(string.Format("Vocal lyric '{0}' at position {1} exceeded the maximum width of 32 bytes.", lyric, i));
foreach (char c in lyric)
{
w.Write(Convert.ToByte(c));
}
// padding after name
w.Write(new byte[32 - lyric.Length]);
}
// unused
w.Write(new byte[254]);
}
}
/// <summary>
/// Equivalent of System.IO.BinaryWriter, but with either endianness, depending on
/// the EndianBitConverter it is constructed with.
/// </summary>
/// <param name="bitConverter">Converter to use when reading data</param>
/// <param name="stream">Stream to read data from</param>
internal EndianBinaryReader (EndianBitConverter bitConverter,
Stream stream) : this (bitConverter, stream, Encoding.UTF8)
{
}
public EndianBinaryReader(EndianBitConverter bitConverter, Stream stream)
: this(bitConverter, stream, System.Text.Encoding.UTF8)
{
}
public BigBinaryWriter(EndianBitConverter bitConverter, System.IO.Stream stream)
: base(bitConverter, stream)
{
}
public static void DecryptSngData(Stream input, Stream output, byte[] key, EndianBitConverter conv)
{
var reader = new EndianBinaryReader(conv, input);
if (0x4A != reader.ReadUInt32())
throw new InvalidDataException("This is not valid SNG file to decrypt.");
reader.ReadBytes(4);//platform header (bitfield? 001 - Compressed; 010 - Encrypted;)
byte[] iv = reader.ReadBytes(16);
using (var rij = new RijndaelManaged())
{
InitRijndael(rij, key, CipherMode.CFB);
rij.IV = iv;
var buffer = new byte[16];
long len = input.Length - input.Position;
for (long i = 0; i < len; i += buffer.Length)
{
using (ICryptoTransform transform = rij.CreateDecryptor())
{
var cs = new CryptoStream(output, transform, CryptoStreamMode.Write);
int bytesread = input.Read(buffer, 0, buffer.Length);
cs.Write(buffer, 0, bytesread);
int pad = buffer.Length - bytesread;
if (pad > 0)
cs.Write(new byte[pad], 0, pad);
cs.Flush();
}
int j;
bool carry;
for (j = (rij.IV.Length) - 1, carry = true; j >= 0 && carry; j--)
carry = ((iv[j] = (byte)(rij.IV[j] + 1)) == 0);
rij.IV = iv;
}
output.SetLength(input.Length - (iv.Length + 8));
}
output.Flush();
output.Seek(0, SeekOrigin.Begin);
}
/// <summary>
/// Equivalent of System.IO.BinaryWriter, but with either endianness, depending on
/// the EndianBitConverter it is constructed with.
/// </summary>
/// <param name="bitConverter">Converter to use when reading data</param>
/// <param name="stream">Stream to read data from</param>
public EndianBinaryReader(EndianBitConverter bitConverter,
Stream stream)
: this(bitConverter, stream, Encoding.UTF8, false)
{
}
public DatabaseBinaryReader(EndianBitConverter bitConverter, Stream stream)
: base(bitConverter, stream)
{
}
/// <summary>
/// Constructs a new binary writer with the given bit converter, writing
/// to the given stream, using UTF-8 encoding.
/// </summary>
/// <param name="bitConverter">Converter to use when writing data</param>
/// <param name="stream">Stream to write data to</param>
public EndianBinaryWriter (EndianBitConverter bitConverter,
Stream stream) : this (bitConverter, stream, Encoding.UTF8)
{
}
public PssgBinaryReader(EndianBitConverter bitConvertor, System.IO.Stream stream)
: base(bitConvertor, stream)
{
}
public static string GenerateSoundBank(string soundbankName, Stream audioStream, Stream outStream, float volume, Platform platform, bool preview = false, bool same = false)
{
bitConverter = platform.GetBitConverter;
int soundbankID = RandomGenerator.NextInt();
int fileID = same ? oldFileID : RandomGenerator.NextInt();
int soundID = same ? oldSoundID : RandomGenerator.NextInt();
oldSoundID = soundID; oldFileID = fileID;
var audioReader = new EndianBinaryReader(bitConverter, audioStream);
byte[] dataChunk = audioReader.ReadBytes(51200); // wwise is based on audio length, we'll just make it up(prefethc lookup is 100ms)
byte[] dataIndexChunk = DataIndex(fileID, dataChunk.Length);
byte[] headerChunk = Header(soundbankID, dataIndexChunk.Length, platform.IsConsole);
byte[] stringIdChunk = StringID(soundbankID, soundbankName);
byte[] hierarchyChunk = Hierarchy(soundbankID, soundID, fileID, soundbankName, volume, preview, platform.IsConsole);
var bankWriter = new EndianBinaryWriter(bitConverter, outStream);
WriteChunk(bankWriter, "BKHD", headerChunk);
WriteChunk(bankWriter, "DIDX", dataIndexChunk);
WriteChunk(bankWriter, "DATA", dataChunk);
WriteChunk(bankWriter, "HIRC", hierarchyChunk);
WriteChunk(bankWriter, "STID", stringIdChunk);
//Flush
bankWriter.Flush();
audioStream.Flush();
outStream.Flush();
audioStream.Position = 0;
outStream.Position = 0;
return fileID.ToString();
}
public EndianBinaryWriterEx(EndianBitConverter bitConvertor, System.IO.Stream stream)
: base(bitConvertor, stream)
{
}
