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); }