public override void ReadSetupData( VorbisCodec codec, BitReader reader )
{
submaps = reader.ReadBit() == 0 ? 1 : reader.ReadBits( 4 ) + 1;
couplingSteps = reader.ReadBit() == 0 ? 0 : reader.ReadBits( 8 ) + 1;
int channels = codec.channels;
if( couplingSteps > 0 && channels > 1 ) {
magnitude = new byte[couplingSteps];
angle = new byte[couplingSteps];
int bits = VorbisUtils.iLog( channels - 1 );
for( int i = 0; i < couplingSteps; i++ ) {
magnitude[i] = (byte)reader.ReadBits( bits );
angle[i] = (byte)reader.ReadBits( bits );
}
}
if( reader.ReadBits( 2 ) != 0 )
throw new InvalidDataException( "Reserved field not 0!" );
if( submaps > 1 ) {
mux = new byte[channels];
for( int i = 0; i < mux.Length; i++ )
mux[i] = (byte)reader.ReadBits( 4 );
} else {
mux = new byte[channels];
}
submapFloor = new byte[submaps];
submapResidue = new byte[submaps];
for( int i = 0; i < submaps; i++ ) {
reader.ReadBits( 8 ); // unused time configuration
submapFloor[i] = (byte)reader.ReadBits( 8 );
submapResidue[i] = (byte)reader.ReadBits( 8 );
}
}
public FlakeReader(string path, Stream IO)
{
_path = path;
_IO = IO != null ? IO : new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 0x10000);
crc8 = new Crc8();
crc16 = new Crc16();
_framesBuffer = new byte[0x20000];
decode_metadata();
frame = new FlacFrame(PCM.ChannelCount);
framereader = new BitReader();
//max_frame_size = 16 + ((Flake.MAX_BLOCKSIZE * PCM.BitsPerSample * PCM.ChannelCount + 1) + 7) >> 3);
if (((int)max_frame_size * PCM.BitsPerSample * PCM.ChannelCount * 2 >> 3) > _framesBuffer.Length)
{
byte[] temp = _framesBuffer;
_framesBuffer = new byte[((int)max_frame_size * PCM.BitsPerSample * PCM.ChannelCount * 2 >> 3)];
if (_framesBufferLength > 0)
Array.Copy(temp, _framesBufferOffset, _framesBuffer, 0, _framesBufferLength);
_framesBufferOffset = 0;
}
_samplesInBuffer = 0;
if ((PCM.BitsPerSample != 16 && PCM.BitsPerSample != 24) || PCM.ChannelCount != 2 || (PCM.SampleRate != 44100 && PCM.SampleRate != 48000))
throw new Exception("invalid flac file");
samplesBuffer = new int[Flake.MAX_BLOCKSIZE * PCM.ChannelCount];
residualBuffer = new int[Flake.MAX_BLOCKSIZE * PCM.ChannelCount];
}
public int ReadCompactInt(Stream stream)
{
using (var binary = new BitReader(stream))
{
return binary.Read7BitInt();
}
}
public static StorageFrameDecoded ReadFrame(Stream source)
{
using (var binary = new BitReader(source))
{
var version = binary.ReadInt64();
var name = binary.ReadString();
var len = binary.Read7BitInt();
var bytes = binary.ReadBytes(len);
var sha1Expected = binary.ReadBytes(20);
var decoded = new StorageFrameDecoded(bytes, name, version);
if (decoded.IsEmpty && sha1Expected.All(b => b == 0))
{
// this looks like end of the stream.
return decoded;
}
//SHA1. TODO: compute hash nicely
var sha1Actual = EncodeFrame(name, bytes, version).Hash;
if (!sha1Expected.SequenceEqual(sha1Actual))
throw new StorageFrameException("SHA mismatch in data frame");
return decoded;
}
}
public FlakeReader(Stream IO)
{
if (IO == null)
{
throw new ArgumentNullException("IO");
}
_IO = IO;
crc8 = new Crc8();
_framesBuffer = new byte[0x20000];
decode_metadata();
frame = new FlacFrame(PCM.ChannelCount);
framereader = new BitReader();
//max_frame_size = 16 + ((Flake.MAX_BLOCKSIZE * PCM.BitsPerSample * PCM.ChannelCount + 1) + 7) >> 3);
if (((int)max_frame_size * PCM.BitsPerSample * PCM.ChannelCount * 2 >> 3) > _framesBuffer.Length)
{
byte[] temp = _framesBuffer;
_framesBuffer = new byte[((int)max_frame_size * PCM.BitsPerSample * PCM.ChannelCount * 2 >> 3)];
if (_framesBufferLength > 0)
Array.Copy(temp, _framesBufferOffset, _framesBuffer, 0, _framesBufferLength);
_framesBufferOffset = 0;
}
_samplesInBuffer = 0;
if (PCM.BitsPerSample != 16 && PCM.BitsPerSample != 24)
throw new Exception("invalid flac file");
samplesBuffer = new int[Flake.MAX_BLOCKSIZE * PCM.ChannelCount];
residualBuffer = new int[Flake.MAX_BLOCKSIZE * PCM.ChannelCount];
}
public void TestRandomFixedFloatRoundTripSerialization()
{
var r = new Random();
for (int n = 0; n < 1000; ++n)
{
var f = (float)((r.NextDouble() * 2) - 1);
for (var i = 0; i < 2; ++i)
{
var bw = new BitWriter(32);
bw.WriteFixedCompressedFloat(f, 1, 16);
var br = new BitReader(bw.GetBits(0, bw.Length).ToArray());
var f2 = br.ReadFixedCompressedFloat(1, 16);
if (i == 0)
{
// We're generating floats that are probably going to lose precision when serialized.
// So the first time around just check to see if we're close.
Assert.IsTrue(Math.Abs(f - f2) < 0.0001);
}
else
{
Assert.AreEqual(f, f2);
}
Assert.AreEqual(bw.Length, br.Position);
f = f2;
}
}
}
public byte[] Decode(Stream stream)
{
using (var ms = new MemoryStream())
{
var br = new BitReader(stream);
int i = 0;
int prevValue = -1;
byte lastChar = 0;
prevValue = br.ReadBits(lookup.CodeLen);
lastChar = lookup.OutputText(lastChar, prevValue, ms);
while (br.BitsRead < br.BitsLength)
{
if (lookup.Count >= 0xFFF)
{
if (br.BitsRead + lookup.CodeLen <= br.BitsLength)
{
lookup.Reset();
prevValue = br.ReadBits(lookup.CodeLen);
lastChar = lookup.OutputText(lastChar, prevValue, ms);
}
else
{
break;
}
continue;
}
int value;
if (br.BitsRead + lookup.CodeLen <= br.BitsLength)
{
lookup.EnsureCodeLen();
value = br.ReadBits(lookup.CodeLen);
}
else
{
break;
}
if (value != lookup.Count)
{
lastChar = lookup.OutputText(lastChar, value, ms);
if (prevValue != -1)
lookup.AppendChar(lastChar, prevValue);
}
else
{
if (prevValue != -1)
lookup.AppendChar(lastChar, prevValue);
lastChar = lookup.OutputText(lastChar, value, ms);
}
prevValue = value;
}
return ms.ToArray();
}
}
public override void ReadSetupData( VorbisCodec codec, BitReader reader )
{
blockFlag = reader.ReadBit();
int windowType = reader.ReadBits( 16 );
int transformType = reader.ReadBits( 16 );
modeMapping = reader.ReadBits( 8 );
if( windowType > 0 || transformType > 0 )
throw new InvalidDataException( "windowType and/or transformType not 0" );
}
public static new PartyLeader Deserialize(BitReader br)
{
PartyLeader pl = new PartyLeader();
List<object> data = new List<object>();
pl.Type = (UniqueIdType)br.ReadByte();
if (pl.Type != UniqueIdType.Unknown)
{
UniqueId.DeserializeId(br, pl);
}
return pl;
}
private long GetEndOffset()
{
if (!File.Exists(Path.Combine(_path, "stream.chk")))
return 0;
using (_checkStream = new FileStream(Path.Combine(_path, "stream.chk"), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (_checkBits = new BitReader(_checkStream))
{
// calculate start and end offset
//_checkStream.Seek(0, SeekOrigin.Begin);
return _checkBits.ReadInt64();
}
}
}
public static UniqueId Deserialize(BitReader br)
{
List<object> data = new List<object>();
var type = (UniqueIdType)br.ReadByte();
UniqueId uid = new UniqueId();
if (type == UniqueIdType.Steam)
{
uid = new SteamId();
}
uid.Type = type;
DeserializeId(br, uid);
return uid;
}
public object ReadMessage(Stream stream)
{
using (var bin = new BitReader(stream))
{
var contract = bin.ReadString();
Formatter formatter;
if (!_formattersByContract.TryGetValue(contract, out formatter))
throw new InvalidOperationException(string.Format("Couldn't find contract type for name '{0}'", contract));
var length = bin.Read7BitInt();
var data = bin.ReadBytes(length);
using (var inner = new MemoryStream(data, 0,length))
{
return formatter.DeserializerDelegate(inner);
}
}
}
public int GetScalarContext( BitReader reader )
{
uint huffCode = 0;
int bits = 1;
int value = 0;
while( bits <= 32 ) {
huffCode <<= 1;
huffCode |= (uint)reader.ReadBit();
if( tree.GetValue( huffCode, bits, out value ) )
break;
bits++;
}
return value;
}
public MessageAttribute[] ReadAttributes(Stream stream)
{
using (var reader = new BitReader(stream))
{
var attributeCount = reader.Read7BitInt();
if (attributeCount == 0) return Empty;
var attributes = new MessageAttribute[attributeCount];
for (var i = 0; i < attributeCount; i++)
{
var key = reader.ReadString();
var value = reader.ReadString();
attributes[i] = new MessageAttribute(key, value);
}
return attributes;
}
}
public IEnumerable<DataRecord> ReadAll(long startOffset, int maxRecordCount)
{
if (startOffset < 0)
throw new ArgumentOutOfRangeException("startOffset");
if (maxRecordCount < 0)
throw new ArgumentOutOfRangeException("maxRecordCount");
var endOffset = GetEndOffset();
if (startOffset >= endOffset)
yield break;
if (!File.Exists(Path.Combine(_path, "stream.dat")))
throw new InvalidOperationException("File stream.chk found but stream.dat file does not exist");
using (_dataStream = new FileStream(Path.Combine(_path, "stream.dat"), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (_dataBits = new BitReader(_dataStream))
{
_dataStream.Seek(startOffset, SeekOrigin.Begin);
int count = 0;
while (_dataStream.Position < endOffset && count <= maxRecordCount)
{
var key = _dataBits.ReadString();
var length = _dataBits.Reader7BitInt();
if (_dataStream.Position + length > _dataStream.Length)
throw new InvalidOperationException("Data length is out of range.");
var data = _dataBits.ReadBytes(length);
yield return new DataRecord(key, data, _dataStream.Position);
if (count == maxRecordCount)
break;
count++;
}
}
}
}
public void TestReadBits()
{
MemoryStream stream = new MemoryStream(new byte[] { 0xe4, 0x1b, 0x1b, 0xf1, 0xff, 0xbb}); // 11100100, 00011011, 00011011
BitReader reader = new BitReader(stream);
Expect(reader.ReadBits(1), EqualTo(0x1));
Expect(reader.ReadBits(2), EqualTo(0x3));
Expect(reader.ReadBits(5), EqualTo(0x4));
ExpectPosition(1, stream);
Expect(reader.ReadBits(7), EqualTo(0xD));
ExpectPosition(2, stream);
Expect(reader.ReadBits(8), EqualTo(0x8D));
ExpectPosition(3, stream);
Expect(reader.ReadBits(2), EqualTo(0x3));
ExpectPosition(4, stream);
Expect(reader.ReadByte(), EqualTo(0xff));
ExpectPosition(5, stream);
Expect(reader.ReadBits(4), EqualTo(0xb));
Expect(reader.ReadBits(4), EqualTo(0xb));
}
void ParseIntraMode(BitReader br, int mb_x)
{
int top = 4 * mb_x; // within intra_t
int left = 0; // within intra_l
var block = m_mb_data[mb_x];
// Note: we don't save segment map (yet), as we don't expect
// to decode more than 1 keyframe.
if (m_segment_hdr.UpdateMap)
{
// Hardcoded tree parsing
block.segment_ = 0 == br.GetBit (m_proba.Segments[0])
? (byte)br.GetBit (m_proba.Segments[1])
: (byte)(2 + br.GetBit (m_proba.Segments[2]));
}
else
{
block.segment_ = 0; // default for intra
}
if (m_use_skip_proba)
block.skip_ = br.GetBit (m_skip_p) != 0;
block.is_i4x4_ = 0 == br.GetBit (145); // decide for B_PRED first
if (!block.is_i4x4_)
{
// Hardcoded 16x16 intra-mode decision tree.
int ymode =
0 != br.GetBit (156) ? (0 != br.GetBit (128) ? TM_PRED : H_PRED)
: (0 != br.GetBit (163) ? V_PRED : DC_PRED);
block.imodes_[0] = (byte)ymode;
for (int i = 0; i < 4; ++i)
{
m_intra_t[top+i] = (byte)ymode;
m_intra_l[left+i] = (byte)ymode;
}
}
else
{
int modes = 0; // within block.imodes_;
for (int y = 0; y < 4; ++y)
{
int ymode = m_intra_l[left + y];
for (int x = 0; x < 4; ++x)
{
int prob = m_intra_t[top + x];
int i = kYModesIntra4[br.GetBit (kBModesProba[prob,ymode,0])];
while (i > 0)
i = kYModesIntra4[2 * i + br.GetBit (kBModesProba[prob,ymode,i])];
ymode = -i;
m_intra_t[top + x] = (byte)ymode;
}
Buffer.BlockCopy (m_intra_t, top, block.imodes_, modes, 4);
modes += 4;
m_intra_l[left + y] = (byte)ymode;
}
}
// Hardcoded UVMode decision tree
block.uvmode_ = 0 == br.GetBit (142) ? DC_PRED
: 0 == br.GetBit (114) ? V_PRED
: 0 != br.GetBit (183) ? TM_PRED : H_PRED;
}
bool ParseFilterHeader(BitReader br)
{
m_filter_hdr.Simple = br.GetNextBit() != 0;
m_filter_hdr.Level = br.GetBits (6);
m_filter_hdr.Sharpness = br.GetBits (3);
m_filter_hdr.UseLfDelta = br.GetNextBit() != 0;
if (m_filter_hdr.UseLfDelta)
{
if (0 != br.GetNextBit())
{ // update lf-delta?
for (int i = 0; i < NumRefLfDeltas; ++i)
{
if (0 != br.GetNextBit())
m_filter_hdr.RefLfDelta[i] = br.GetSignedValue (6);
}
for (int i = 0; i < NumModeLfDeltas; ++i)
{
if (0 != br.GetNextBit())
m_filter_hdr.ModeLfDelta[i] = br.GetSignedValue (6);
}
}
}
m_filter_type = (0 == m_filter_hdr.Level) ? 0 : m_filter_hdr.Simple ? 1 : 2;
return !br.Eof;
}
void GetHeaders()
{
int chunk_size = m_info.DataSize;
int bits = ReadInt24();
chunk_size -= 3;
m_frame_header.KeyFrame = 0 == (bits & 1);
m_frame_header.Profile = (bits >> 1) & 7;
m_frame_header.Show = 0 != (bits & (1u << 4));
m_frame_header.PartitionLength = bits >> 5;
if (m_frame_header.Profile > 3)
throw new InvalidFormatException ("Incorrect keyframe parameters.");
if (!m_frame_header.Show)
throw new InvalidFormatException ("Frame not displayable.");
if (m_frame_header.KeyFrame)
{
// Paragraph 9.2
if (!CheckSignature())
throw new InvalidFormatException ("Bad code word");
ushort w = m_input.ReadUInt16();
ushort h = m_input.ReadUInt16();
m_pic_hdr.Width = (ushort)(w & 0x3fff);
m_pic_hdr.XScale = (byte)(w >> 14); // ratio: 1, 5/4 5/3 or 2
m_pic_hdr.Height = (ushort)(h & 0x3fff);
m_pic_hdr.YScale = (byte)(h >> 14);
chunk_size -= 7;
mb_w_ = (m_pic_hdr.Width + 15) >> 4;
mb_h_ = (m_pic_hdr.Height + 15) >> 4;
// Setup default output area (can be later modified during m_io.setup())
m_io.width = m_pic_hdr.Width;
m_io.height = m_pic_hdr.Height;
m_io.mb_w = m_io.width;
m_io.mb_h = m_io.height;
m_proba.Reset();
m_segment_hdr.Reset();
}
if (m_frame_header.PartitionLength > chunk_size)
throw new InvalidFormatException ("bad partition length");
m_br = new BitReader (m_input, m_frame_header.PartitionLength);
chunk_size -= m_frame_header.PartitionLength;
if (m_frame_header.KeyFrame)
{
m_pic_hdr.Colorspace = (byte)m_br.GetNextBit();
m_pic_hdr.ClampType = (byte)m_br.GetNextBit();
}
if (!ParseSegmentHeader (m_br))
throw new InvalidFormatException ("Cannot parse segment header");
// Filter specs
if (!ParseFilterHeader (m_br))
throw new InvalidFormatException ("Cannot parse filter header");
if (!ParsePartitions (m_br, chunk_size))
throw new InvalidFormatException ("Cannot parse partitions");
for (int i = 0; i < m_dqm.Length; ++i)
m_dqm[i] = new QuantMatrix();
// quantizer change
ParseQuant (m_br);
// Frame buffer marking
if (!m_frame_header.KeyFrame)
throw new InvalidFormatException ("Not a key frame");
m_br.GetNextBit(); // ignore the value of update_proba_
ParseProba (m_br);
}
int GetCoeffs(BitReader br, BandProbas[] prob, int ctx, int[] dq, int n, short[] out_ptr, int dst)
{
var p = prob[n].Probas[ctx];
for (; n < 16; ++n)
{
if (0 == br.GetBit (p[0]))
return n; // previous coeff was last non-zero coeff
while (0 == br.GetBit (p[1])) // sequence of zero coeffs
{
p = prob[++n].Probas[0];
if (16 == n) return 16;
}
// non zero coeff
var p_ctx = prob[n + 1].Probas;
int v;
if (0 == br.GetBit (p[2]))
{
v = 1;
p = p_ctx[1];
}
else
{
v = br.GetLargeValue (p);
p = p_ctx[2];
}
out_ptr[dst+kZigzag[n]] = (short)(br.GetSigned (v) * dq[n > 0 ? 1 : 0]);
}
return 16;
}
bool DecodeMB(BitReader token_br)
{
int left = m_mb_info - 1;
int mb = m_mb_info + mb_x_;
var block = m_mb_data[mb_x_];
bool skip = m_use_skip_proba && block.skip_;
if (!skip)
{
skip = ParseResiduals (mb, token_br);
}
else
{
m_mb[left].nz_ = m_mb[mb].nz_ = 0;
if (!block.is_i4x4_)
m_mb[left].nz_dc_ = m_mb[mb].nz_dc_ = 0;
block.non_zero_y_ = 0;
block.non_zero_uv_ = 0;
}
if (m_filter_type > 0) // store filter info
{
int finfo = mb_x_;
m_filter_info[finfo] = m_fstrengths[block.segment_, block.is_i4x4_ ? 1 : 0];
m_filter_info[finfo].f_inner_ |= (byte)(skip ? 0 : 1);
}
return !token_br.Eof;
}
bool ParseResiduals(int mb, BitReader token_br)
{
var bands = m_proba.BandsPtr;
BandProbas[] ac_proba;
var block = m_mb_data[mb_x_];
var q = m_dqm[block.segment_];
int dst = 0; // block->coeffs_
int left_mb = m_mb_info - 1;
uint non_zero_y = 0;
uint non_zero_uv = 0;
int x, y;
uint out_t_nz, out_l_nz;
int first;
for (int i = 0; i < 384; ++i)
block.coeffs_[i] = 0;
if (!block.is_i4x4_) // parse DC
{
var dc = new short[16];
int ctx = m_mb[mb].nz_dc_ + m_mb[left_mb].nz_dc_;
int nz = GetCoeffs (token_br, bands[1], ctx, q.y2_mat, 0, dc, 0);
m_mb[mb].nz_dc_ = m_mb[left_mb].nz_dc_ = (byte)(nz > 0 ? 1 : 0);
if (nz > 1)
{ // more than just the DC -> perform the full transform
TransformWHT (dc, block.coeffs_, dst);
}
else
{ // only DC is non-zero -> inlined simplified transform
int dc0 = (dc[0] + 3) >> 3;
for (int i = 0; i < 16 * 16; i += 16)
block.coeffs_[dst+i] = (short)dc0;
}
first = 1;
ac_proba = bands[0];
}
else
{
first = 0;
ac_proba = bands[3];
}
byte tnz = (byte)(m_mb[mb].nz_ & 0xF);
byte lnz = (byte)(m_mb[left_mb].nz_ & 0xF);
for (y = 0; y < 4; ++y)
{
int l = lnz & 1;
uint nz_coeffs = 0;
for (x = 0; x < 4; ++x)
{
int ctx = l + (tnz & 1);
int nz = GetCoeffs (token_br, ac_proba, ctx, q.y1_mat, first, block.coeffs_, dst);
l = nz > first ? 1 : 0;
tnz = (byte)((tnz >> 1) | (l << 7));
nz_coeffs = NzCodeBits (nz_coeffs, nz, block.coeffs_[dst] != 0 ? 1 : 0);
dst += 16;
}
tnz >>= 4;
lnz = (byte)((lnz >> 1) | (l << 7));
non_zero_y = (non_zero_y << 8) | nz_coeffs;
}
out_t_nz = tnz;
out_l_nz = (uint)(lnz >> 4);
for (int ch = 0; ch < 4; ch += 2)
{
uint nz_coeffs = 0;
tnz = (byte)(m_mb[mb].nz_ >> (4 + ch));
lnz = (byte)(m_mb[left_mb].nz_ >> (4 + ch));
for (y = 0; y < 2; ++y)
{
int l = lnz & 1;
for (x = 0; x < 2; ++x)
{
int ctx = l + (tnz & 1);
int nz = GetCoeffs (token_br, bands[2], ctx, q.uv_mat, 0, block.coeffs_, dst);
l = nz > 0 ? 1 : 0;
tnz = (byte)((tnz >> 1) | (l << 3));
nz_coeffs = NzCodeBits (nz_coeffs, nz, block.coeffs_[dst] != 0 ? 1 : 0);
dst += 16;
}
tnz >>= 2;
lnz = (byte)((lnz >> 1) | (l << 5));
}
// Note: we don't really need the per-4x4 details for U/V blocks.
non_zero_uv |= nz_coeffs << (4 * ch);
out_t_nz |= (uint)(tnz << 4) << ch;
out_l_nz |= (uint)(lnz & 0xf0) << ch;
}
m_mb[mb].nz_ = (byte)out_t_nz;
m_mb[left_mb].nz_ = (byte)out_l_nz;
block.non_zero_y_ = non_zero_y;
block.non_zero_uv_ = non_zero_uv;
return 0 == (non_zero_y | non_zero_uv); // will be used for further optimization
}
void ParseProba(BitReader br)
{
for (int t = 0; t < NumTypes; ++t)
{
for (int b = 0; b < NumBands; ++b)
for (int c = 0; c < NumCtx; ++c)
for (int p = 0; p < NumProbas; ++p)
{
int v = br.GetBit (CoeffsUpdateProba[t,b,c,p]) != 0 ?
br.GetBits (8) : CoeffsProba0[t,b,c,p];
m_proba.Bands[t,b].Probas[c][p] = (byte)v;
}
for (int b = 0; b < 16 + 1; ++b)
{
m_proba.BandsPtr[t][b] = m_proba.Bands[t,kBands[b]];
}
}
m_use_skip_proba = br.GetNextBit() != 0;
if (m_use_skip_proba)
m_skip_p = br.GetBits (8);
}
bool ParseIntraModeRow(BitReader br)
{
for (int mb_x = 0; mb_x < mb_w_; ++mb_x)
ParseIntraMode (br, mb_x);
return !m_br.Eof;
}
bool ParsePartitions(BitReader br, int size)
{
long part_end = m_input.BaseStream.Position + size;
int size_left = size;
m_num_parts = 1 << br.GetBits (2);
int last_part = m_num_parts - 1;
if (size < 3 * last_part)
return false;
long part_start = m_input.BaseStream.Position + last_part * 3;
size_left -= last_part * 3;
for (int p = 0; p < last_part; ++p)
{
int psize = ReadInt24();
var sz_pos = m_input.BaseStream.Position;
if (psize > size_left) psize = size_left;
m_input.BaseStream.Position = part_start;
m_parts[p] = new BitReader (m_input, psize);
part_start += psize;
size_left -= psize;
m_input.BaseStream.Position = sz_pos;
}
m_input.BaseStream.Position = part_start;
m_parts[last_part] = new BitReader (m_input, size_left);
return part_start < part_end;
}
public FlakeReader(AudioPCMConfig _pcm)
{
pcm = _pcm;
crc8 = new Crc8();
crc16 = new Crc16();
samplesBuffer = new int[Flake.MAX_BLOCKSIZE * PCM.ChannelCount];
residualBuffer = new int[Flake.MAX_BLOCKSIZE * PCM.ChannelCount];
frame = new FlacFrame(PCM.ChannelCount);
framereader = new BitReader();
}
void ParseQuant(BitReader br)
{
int base_q0 = br.GetBits (7);
int dqy1_dc = br.GetNextBit() != 0 ? br.GetSignedValue (4) : 0;
int dqy2_dc = br.GetNextBit() != 0 ? br.GetSignedValue (4) : 0;
int dqy2_ac = br.GetNextBit() != 0 ? br.GetSignedValue (4) : 0;
int dquv_dc = br.GetNextBit() != 0 ? br.GetSignedValue (4) : 0;
int dquv_ac = br.GetNextBit() != 0 ? br.GetSignedValue (4) : 0;
for (int i = 0; i < NumMbSegments; ++i)
{
int q;
if (m_segment_hdr.UseSegment)
{
q = m_segment_hdr.Quantizer[i];
if (!m_segment_hdr.AbsoluteDelta)
q += base_q0;
}
else if (i > 0)
{
m_dqm[i] = m_dqm[0];
continue;
}
else
{
q = base_q0;
}
var m = m_dqm[i];
m.y1_mat[0] = kDcTable[Clip (q + dqy1_dc, 127)];
m.y1_mat[1] = kAcTable[Clip (q + 0, 127)];
m.y2_mat[0] = kDcTable[Clip (q + dqy2_dc, 127)] * 2;
// For all x in [0..284], x*155/100 is bitwise equal to (x*101581) >> 16.
// The smallest precision for that is '(x*6349) >> 12' but 16 is a good
// word size.
m.y2_mat[1] = (kAcTable[Clip (q + dqy2_ac, 127)] * 101581) >> 16;
if (m.y2_mat[1] < 8) m.y2_mat[1] = 8;
m.uv_mat[0] = kDcTable[Clip (q + dquv_dc, 117)];
m.uv_mat[1] = kAcTable[Clip (q + dquv_ac, 127)];
m.uv_quant = q + dquv_ac; // for dithering strength evaluation
}
}
unsafe void decode_subframe_lpc(BitReader bitreader, FlacFrame frame, int ch)
{
// warm-up samples
int obits = frame.subframes[ch].obits;
for (int i = 0; i < frame.subframes[ch].best.order; i++)
frame.subframes[ch].best.residual[i] = bitreader.readbits_signed(obits);
// LPC coefficients
frame.subframes[ch].best.cbits = (int)bitreader.readbits(4) + 1; // lpc_precision
frame.subframes[ch].best.shift = bitreader.readbits_signed(5);
if (frame.subframes[ch].best.shift < 0)
throw new Exception("negative shift");
for (int i = 0; i < frame.subframes[ch].best.order; i++)
frame.subframes[ch].best.coefs[i] = bitreader.readbits_signed(frame.subframes[ch].best.cbits);
// residual
decode_residual(bitreader, frame, ch);
}
bool ParseSegmentHeader(BitReader br)
{
m_segment_hdr.UseSegment = br.GetNextBit() != 0;
if (m_segment_hdr.UseSegment)
{
m_segment_hdr.UpdateMap = br.GetNextBit() != 0;
if (0 != br.GetNextBit())
{ // update data
m_segment_hdr.AbsoluteDelta = br.GetNextBit() != 0;
for (int s = 0; s < NumMbSegments; ++s)
{
m_segment_hdr.Quantizer[s] = (byte)(br.GetNextBit() != 0 ? br.GetSignedValue (7) : 0);
}
for (int s = 0; s < NumMbSegments; ++s)
{
m_segment_hdr.FilterStrength[s] = (byte)(br.GetNextBit() != 0 ? br.GetSignedValue (6) : 0);
}
}
if (m_segment_hdr.UpdateMap)
{
for (int s = 0; s < TreeProbs; ++s)
{
m_proba.Segments[s] = (byte)(br.GetNextBit() != 0 ? br.GetBits (8) : 255);
}
}
}
else
{
m_segment_hdr.UpdateMap = false;
}
return !br.Eof;
}
unsafe void decode_subframe_verbatim(BitReader bitreader, FlacFrame frame, int ch)
{
int obits = frame.subframes[ch].obits;
for (int i = 0; i < frame.blocksize; i++)
frame.subframes[ch].best.residual[i] = bitreader.readbits_signed(obits);
}
