public FlacSubFrameConstant(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bitsPerSample) : base(header) { unchecked { var value = (int)reader.ReadBits(bitsPerSample); data.DestinationBuffer.Span.Fill(value); } }
public unsafe FlacSubFrameLPC(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bps, int order) : base(header) { //warmup _warmup = new int[FlacConstant.MAX_LPC_ORDER]; for (int i = 0; i < order; i++) { _warmup[i] = data.residualBuffer[i] = reader.ReadBitsSigned(bps); } //header int u32 = (int)reader.ReadBits(FlacConstant.SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN); if (u32 == (1 << FlacConstant.SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN) - 1) { Debug.WriteLine("Invalid FlacLPC qlp coeff precision."); return; //return false; } _qlpCoeffPrecision = u32 + 1; int level = reader.ReadBitsSigned(FlacConstant.SUBFRAME_LPC_QLP_SHIFT_LEN); if (level < 0) throw new Exception("negative shift"); _lpcShiftNeeded = level; _qlpCoeffs = new int[FlacConstant.MAX_LPC_ORDER]; //qlp coeffs for (int i = 0; i < order; i++) { _qlpCoeffs[i] = reader.ReadBitsSigned(_qlpCoeffPrecision); } //QLPCoeffs = coeffs; Residual = new FlacResidual(reader, header, data, order); for (int i = 0; i < order; i++) { data.destBuffer[i] = data.residualBuffer[i]; } if (bps + _qlpCoeffPrecision + CSMath.ILog(order) <= 32) { if (bps <= 16 && _qlpCoeffPrecision <= 16) RestoreLPCSignal(data.residualBuffer + order, data.destBuffer + order, header.BlockSize - order, order); //Restore(data.residualBuffer + order, data.destBuffer, Header.BlockSize - order, order, order); else RestoreLPCSignal(data.residualBuffer + order, data.destBuffer + order, header.BlockSize - order, order); } else { RestoreLPCSignalWide(data.residualBuffer + order, data.destBuffer + order, header.BlockSize - order, order);//RestoreWide(data.residualBuffer + order, data.destBuffer, Header.BlockSize - order, order, order); } //Warmup = warmup; }
public unsafe FlacSubFrameLPC(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bitsPerSample, int order) : base(header) { var warmup = new int[order]; for (int i = 0; i < order; i++) { warmup[i] = data.ResidualBuffer[i] = reader.ReadBitsSigned(bitsPerSample); } int coefPrecision = (int)reader.ReadBits(4) + 1; if (coefPrecision == 0x0F) { Debug.WriteLine("Invalid linear predictor coefficients' precision. Must not be 0x0F."); return; } int shiftNeeded = reader.ReadBitsSigned(5); if (shiftNeeded < 0) throw new FlacException("\"Quantized linear predictor coefficient shift needed.\" was negative.", FlacLayer.SubFrame); var q = new int[order]; for (int i = 0; i < order; i++) { q[i] = reader.ReadBitsSigned(coefPrecision); } //decode the residual var residual = new FlacResidual(reader, header, data, order); for (int i = 0; i < order; i++) { data.DestinationBuffer[i] = data.ResidualBuffer[i]; } int* residualBuffer0 = data.ResidualBuffer + order; int* destinationBuffer0 = data.DestinationBuffer + order; int blockSizeToProcess = header.BlockSize - order; if (bitsPerSample + coefPrecision + Log2(order) <= 32) { RestoreLPCSignal32(residualBuffer0, destinationBuffer0, blockSizeToProcess, order, q, shiftNeeded); } else { RestoreLPCSignal64(residualBuffer0, destinationBuffer0, blockSizeToProcess, order, q, shiftNeeded); } #if FLAC_DEBUG QLPCoeffPrecision = coefPrecision; LPCShiftNeeded = shiftNeeded; Warmup = warmup; Residual = residual; QLPCoeffs = q; #endif }
public unsafe FlacSubFrameFixed(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bps, int order) : base(header) { for (int i = 0; i < order; i++) { data.residualBuffer[i] = data.destBuffer[i] = reader.ReadBitsSigned(bps); } Residual = new FlacResidual(reader, header, data, order); RestoreSignal(data, header.BlockSize - order, order); }
public FlacSubFrameLPC(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bitsPerSample, int order) : base(header) { unchecked { var resi = data.ResidualBuffer.Span; var dest = data.DestinationBuffer.Span; for (var i = 0; i < order; i++) { resi[i] = reader.ReadBitsSigned(bitsPerSample); } var coefPrecision = (int)reader.ReadBits(4); if (coefPrecision == 0x0F) { throw new FlacException( "Invalid \"quantized linear predictor coefficients' precision in bits\" was invalid. Must not be 0x0F.", FlacLayer.SubFrame); } coefPrecision += 1; var shiftNeeded = reader.ReadBitsSigned(5); if (shiftNeeded < 0) { throw new FlacException( "'\"Quantized linear predictor coefficient shift needed in bits\" was negative.", FlacLayer.SubFrame); } var q = new int[order]; for (var i = 0; i < order; i++) { q[i] = reader.ReadBitsSigned(coefPrecision); } //decode the residual new FlacResidual(reader, header, data, order); resi.Slice(0, order).CopyTo(dest); var blockSizeToProcess = header.BlockSize - order; if (bitsPerSample + coefPrecision + Log2(order) <= 32) { RestoreLPCSignal32(resi, dest, blockSizeToProcess, order, q, shiftNeeded); } else { RestoreLPCSignal64(resi, dest, blockSizeToProcess, order, q, shiftNeeded); } } }
private void Decode(Stream stream, FlacMetadataStreamInfo streamInfo) { Header = new FlacFrameHeader(stream, streamInfo); _stream = stream; _streamInfo = streamInfo; HasError = Header.HasError; if (!HasError) { ReadSubFrames(); FreeBuffers(); } }
public unsafe FlacSubFrameFixed(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bitsPerSample, int order) : base(header) { for (int i = 0; i < order; i++) //order = predictor order { data.ResidualBuffer[i] = data.DestinationBuffer[i] = reader.ReadBitsSigned(bitsPerSample); } var residual = new FlacResidual(reader, header, data, order); //necessary for decoding RestoreSignal(data, header.BlockSize - order, order); #if FLAC_DEBUG Residual = residual; #endif }
public FlacResidual(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int order) { var codingMethod = (FlacResidualCodingMethod)reader.ReadBits(2); // 2 Bit if (codingMethod == FlacResidualCodingMethod.PartitionedRice || codingMethod == FlacResidualCodingMethod.PartitionedRice2) { var partitionOrder = (int)reader.ReadBits(4); //"Partition order." see https://xiph.org/flac/format.html#partitioned_rice and https://xiph.org/flac/format.html#partitioned_rice2 FlacPartitionedRice.ProcessResidual(reader, header, data, order, partitionOrder, codingMethod); } else { throw new FlacException("Not supported RICE-Coding-Method. Stream unparseable!", FlacLayer.SubFrame); } }
public FlacSubFrameVerbatim(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bitsPerSample) : base(header) { unchecked { var dest = data.DestinationBuffer.Span; var resi = data.ResidualBuffer.Span; for (var i = 0; i < header.BlockSize; i++) { var x = (int)reader.ReadBits(bitsPerSample); dest[i] = resi[i] = x; } } }
public FlacSubFrameFixed(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bitsPerSample, int order) : base(header) { unchecked { var resi = data.ResidualBuffer.Span; var dest = data.DestinationBuffer.Span; for (var i = 0; i < order; i++) //order = predictor order { resi[i] = dest[i] = reader.ReadBitsSigned(bitsPerSample); } new FlacResidual(reader, header, data, order); //necessary for decoding RestoreSignal(data, header.BlockSize - order, order); } }
public unsafe bool ProcessResidual(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int order) { data.Content.UpdateSize(PartitionOrder); int porder = PartitionOrder; FlacEntropyCoding codingMethod = CodingMethod; int psize = header.BlockSize >> porder; int res_cnt = psize - order; int ricelength = 4 + (int)codingMethod; //4bit = RICE I | 5bit = RICE II //residual int j = order; int *r = data.residualBuffer + j; int partitioncount = 1 << porder; for (int p = 0; p < partitioncount; p++) { if (p == 1) { res_cnt = psize; } int n = Math.Min(res_cnt, header.BlockSize - j); int k = Content.parameters[p] = (int)reader.ReadBits(ricelength); if (k == (1 << ricelength) - 1) { k = (int)reader.ReadBits(5); for (int i = n; i > 0; i--) { *(r) = reader.ReadBitsSigned((int)k); } } else { ReadFlacRiceBlock(reader, n, (int)k, r); r += n; } j += n; } return(true); }
public unsafe bool ProcessResidual(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int order) { data.Content.UpdateSize(PartitionOrder); int porder = PartitionOrder; FlacEntropyCoding codingMethod = CodingMethod; int psize = header.BlockSize >> porder; int res_cnt = psize - order; int ricelength = 4 + (int)codingMethod; //4bit = RICE I | 5bit = RICE II //residual int j = order; int* r = data.residualBuffer + j; int partitioncount = 1 << porder; for (int p = 0; p < partitioncount; p++) { if (p == 1) res_cnt = psize; int n = Math.Min(res_cnt, header.BlockSize - j); int k = Content.parameters[p] = (int)reader.ReadBits(ricelength); if (k == (1 << ricelength) - 1) { k = (int)reader.ReadBits(5); for (int i = n; i > 0; i--) { *(r) = reader.ReadBitsSigned((int)k); } } else { ReadFlacRiceBlock(reader, n, (int)k, r); r += n; } j += n; } return true; }
private unsafe void Decode(Stream stream, FlacMetadataStreamInfo streamInfo) { Header = new FlacFrameHeader(stream, streamInfo); _stream = stream; _streamInfo = streamInfo; HasError = Header.HasError; if (!HasError) { if (_destBuffer == null || _destBuffer.Length < (Header.Channels * Header.BlockSize)) { _destBuffer = new int[Header.Channels * Header.BlockSize]; } if (_residualBuffer == null || _residualBuffer.Length < (Header.Channels * Header.BlockSize)) _residualBuffer = new int[Header.Channels * Header.BlockSize]; fixed(int *ptrDestBuffer = _destBuffer, ptrResidualBuffer = _residualBuffer) { ReadSubFrames(ptrDestBuffer, ptrResidualBuffer); } //FreeBuffers(); } }
public static unsafe FlacSubFrameBase GetSubFrame(FlacBitReader reader, FlacSubFrameData data, FlacFrameHeader header, int bitsPerSample) { int wastedBits = 0, order; uint firstByte = reader.ReadBits(8); if ((firstByte & 0x80) != 0) //Zero bit padding, to prevent sync-fooling string of 1s { Debug.WriteLine("Flacdecoder subframe-header got no zero-bit padding."); return null; } bool hasWastedBits = (firstByte & 1) != 0; //Wasted bits-per-sample' flag if (hasWastedBits) { int k = (int)reader.ReadUnary(); wastedBits = k + 1; //"k-1" follows -> add 1 bitsPerSample -= wastedBits; } FlacSubFrameBase subFrame; var subframeType = (firstByte & 0x7E) >> 1; //0111 1110 if (subframeType == 0) //000000 { subFrame = new FlacSubFrameConstant(reader, header, data, bitsPerSample); } else if (subframeType == 1) //000001 { subFrame = new FlacSubFrameVerbatim(reader, header, data, bitsPerSample); } else if ((subframeType & 0x08) != 0) //001000 = 0x08 { order = (int) (subframeType & 0x07); subFrame = new FlacSubFrameFixed(reader, header, data, bitsPerSample, order); } else if ((subframeType & 0x20) != 0) //100000 = 0x20 { order = (int) (subframeType & 0x1F) + 1; subFrame = new FlacSubFrameLPC(reader, header, data, bitsPerSample, order); } else { Debug.WriteLine(String.Format("Invalid Flac-SubframeType. SubframeType: 0x{0:x}.", subframeType)); return null; } if (hasWastedBits) { int* destination = data.DestinationBuffer; for (int i = 0; i < header.BlockSize; i++) { *(destination++) <<= wastedBits; } } #if FLAC_DEBUG subFrame.WastedBits = wastedBits; #endif return subFrame; }
protected FlacSubFrameBase(FlacFrameHeader header) { #if FLAC_DEBUG Header = header; #endif }
protected FlacSubFrameBase(FlacFrameHeader header) { Header = header; }
private unsafe bool IsFrame(ref byte* buffer, FlacMetadataStreamInfo streamInfo, FlacFrameHeader baseHeader, out FlacFrameHeader header) { header = new FlacFrameHeader(ref buffer, streamInfo, true, false); return !header.HasError; }
/// <summary> /// Indicates whether the format of the current <see cref="FlacFrameHeader"/> is equal to the format of another <see cref="FlacFrameHeader"/>. /// </summary> /// <param name="other">A <see cref="FlacFrameHeader"/> which provides the format to compare with the format of the current <see cref="FlacFrameHeader"/>.</param> /// <returns><c>true</c> if the format of the current <see cref="FlacFrameHeader"/> is equal to the format of the <paramref name="other"/> <see cref="FlacFrameHeader"/>.</returns> public bool IsFormatEqualTo(FlacFrameHeader other) { return(BitsPerSample == other.BitsPerSample && Channels == other.Channels && SampleRate == other.SampleRate); }
public bool CompareTo(FlacFrameHeader header) { return (BitsPerSample == header.BitsPerSample && Channels == header.Channels && SampleRate == header.SampleRate); }
public bool CompareTo(FlacFrameHeader header) { return(BitsPerSample == header.BitsPerSample && Channels == header.Channels && SampleRate == header.SampleRate); }
public unsafe static FlacSubFrameBase GetSubFrame(FlacBitReader reader, FlacSubFrameData data, FlacFrameHeader header, int bitsPerSample) { int wastedBits = 0, order; uint firstByte = reader.ReadBits(8); if ((firstByte & 0x80) != 0) //Zero bit padding, to prevent sync-fooling string of 1s { Debug.WriteLine("Flacdecoder subframe-header got no zero-bit padding."); return(null); } bool hasWastedBits = (firstByte & 1) != 0; //Wasted bits-per-sample' flag if (hasWastedBits) { int k = (int)reader.ReadUnary(); wastedBits = k + 1; //"k-1" follows -> add 1 bitsPerSample -= wastedBits; } FlacSubFrameBase subFrame; var subframeType = (firstByte & 0x7E) >> 1; //0111 1110 if (subframeType == 0) //000000 { subFrame = new FlacSubFrameConstant(reader, header, data, bitsPerSample); } else if (subframeType == 1) //000001 { subFrame = new FlacSubFrameVerbatim(reader, header, data, bitsPerSample); } else if ((subframeType & 0x08) != 0) //001000 = 0x08 { order = (int)(subframeType & 0x07); subFrame = new FlacSubFrameFixed(reader, header, data, bitsPerSample, order); } else if ((subframeType & 0x20) != 0) //100000 = 0x20 { order = (int)(subframeType & 0x1F) + 1; subFrame = new FlacSubFrameLPC(reader, header, data, bitsPerSample, order); } else { Debug.WriteLine(String.Format("Invalid Flac-SubframeType. SubframeType: 0x{0:x}.", subframeType)); return(null); } if (hasWastedBits) { int *destination = data.DestinationBuffer; for (int i = 0; i < header.BlockSize; i++) { *(destination++) <<= wastedBits; } } #if FLAC_DEBUG subFrame.WastedBits = wastedBits; #endif return(subFrame); }
private unsafe bool IsFrame(ref byte* buffer, FlacMetadataStreamInfo streamInfo, out FlacFrameHeader header) { header = new FlacFrameHeader(ref buffer, streamInfo, true, false); return !header.HasError; }
protected FlacSubFrameBase(FlacFrameHeader header) { }
public unsafe FlacSubFrameLPC(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bps, int order) : base(header) { //warmup _warmup = new int[FlacConstant.MAX_LPC_ORDER]; for (int i = 0; i < order; i++) { _warmup[i] = data.residualBuffer[i] = reader.ReadBitsSigned(bps); } //header int u32 = (int)reader.ReadBits(FlacConstant.SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN); if (u32 == (1 << FlacConstant.SUBFRAME_LPC_QLP_COEFF_PRECISION_LEN) - 1) { Debug.WriteLine("Invalid FlacLPC qlp coeff precision."); return; //return false; } _qlpCoeffPrecision = u32 + 1; int level = reader.ReadBitsSigned(FlacConstant.SUBFRAME_LPC_QLP_SHIFT_LEN); if (level < 0) { throw new Exception("negative shift"); } _lpcShiftNeeded = level; _qlpCoeffs = new int[FlacConstant.MAX_LPC_ORDER]; //qlp coeffs for (int i = 0; i < order; i++) { _qlpCoeffs[i] = reader.ReadBitsSigned(_qlpCoeffPrecision); } //QLPCoeffs = coeffs; Residual = new FlacResidual(reader, header, data, order); for (int i = 0; i < order; i++) { data.destBuffer[i] = data.residualBuffer[i]; } if (bps + _qlpCoeffPrecision + CSMath.ILog(order) <= 32) { if (bps <= 16 && _qlpCoeffPrecision <= 16) { RestoreLPCSignal(data.residualBuffer + order, data.destBuffer + order, header.BlockSize - order, order); //Restore(data.residualBuffer + order, data.destBuffer, Header.BlockSize - order, order, order); } else { RestoreLPCSignal(data.residualBuffer + order, data.destBuffer + order, header.BlockSize - order, order); } } else { RestoreLPCSignalWide(data.residualBuffer + order, data.destBuffer + order, header.BlockSize - order, order);//RestoreWide(data.residualBuffer + order, data.destBuffer, Header.BlockSize - order, order, order); } //Warmup = warmup; }
/// <summary> /// Indicates whether the format of the current <see cref="FlacFrameHeader"/> is equal to the format of another <see cref="FlacFrameHeader"/>. /// </summary> /// <param name="other">A <see cref="FlacFrameHeader"/> which provides the format to compare with the format of the current <see cref="FlacFrameHeader"/>.</param> /// <returns><c>true</c> if the format of the current <see cref="FlacFrameHeader"/> is equal to the format of the <paramref name="other"/> <see cref="FlacFrameHeader"/>.</returns> public bool IsFormatEqualTo(FlacFrameHeader other) { return (BitsPerSample == other.BitsPerSample && Channels == other.Channels && SampleRate == other.SampleRate); }
public unsafe static FlacSubFrameBase GetSubFrame(FlacBitReader reader, FlacSubFrameData data, FlacFrameHeader header, int bps) { uint x; int wastedBits = 0, totalBits = 0, order = 0; x = reader.ReadBits(8); bool haswastedBits = (x & 1) != 0; x &= 0xFE; //1111 1110 if (haswastedBits) { int u = (int)reader.ReadUnary(); wastedBits = u + 1; bps -= wastedBits; totalBits = bps; } if ((x & 0x80) != 0) { Debug.WriteLine("Flacdecoder lost sync while reading FlacSubFrameHeader. [x & 0x80]."); return(null); } FlacSubFrameBase subFrame = null; if ((x > 2 && x < 16) || (x > 24 && x < 64)) { Debug.WriteLine("Invalid FlacSubFrameHeader. [" + x.ToString("x") + "]"); return(null); } else if (x == 0) { subFrame = new FlacSubFrameConstant(reader, header, data, bps); } else if (x == 2) { //verbatim subFrame = new FlacSubFrameVerbatim(reader, header, data, bps); } else if (x >= 16 && x <= 24) { //fixed order = (int)((x >> 1) & 7); subFrame = new FlacSubFrameFixed(reader, header, data, bps, order); } else if (x >= 64) { //lpc order = (int)(((x >> 1) & 31) + 1); subFrame = new FlacSubFrameLPC(reader, header, data, bps, order); } else { Debug.WriteLine("Invalid Flac-SubframeType: x = " + x + "."); return(null); } if (haswastedBits) { int *ptrDest = data.destBuffer; for (int i = 0; i < header.BlockSize; i++) { *(ptrDest++) <<= wastedBits; } } //System.Diagnostics.Debug.WriteLine(subFrame.GetType().Name); if (subFrame != null) { subFrame.WastedBits = wastedBits; } else { Debug.WriteLine("Unknown error while reading FlacSubFrameHeader"); } return(subFrame); }
public static FlacSubFrameBase GetSubFrame(FlacBitReader reader, FlacSubFrameData data, FlacFrameHeader header, int bitsPerSample) { unchecked { int wastedBits = 0, order; var firstByte = reader.ReadBits(8); if ((firstByte & 0x80) != 0) //Zero bit padding, to prevent sync-fooling string of 1s { Debug.WriteLine("Flacdecoder subframe-header got no zero-bit padding."); return(null); } var hasWastedBits = (firstByte & 1) != 0; //Wasted bits-per-sample' flag if (hasWastedBits) { var k = (int)reader.ReadUnary(); wastedBits = k + 1; //"k-1" follows -> add 1 bitsPerSample -= wastedBits; } FlacSubFrameBase subFrame; var subframeType = (firstByte & 0x7E) >> 1; //0111 1110 if (subframeType == 0) //000000 { subFrame = new FlacSubFrameConstant(reader, header, data, bitsPerSample); } else if (subframeType == 1) //000001 { subFrame = new FlacSubFrameVerbatim(reader, header, data, bitsPerSample); } else if ((subframeType & 0x20) != 0) //100000 = 0x20 { order = (int)(subframeType & 0x1F) + 1; subFrame = new FlacSubFrameLPC(reader, header, data, bitsPerSample, order); } else if ((subframeType & 0x08) != 0) //001000 = 0x08 { order = (int)(subframeType & 0x07); if (order > 4) { return(null); } subFrame = new FlacSubFrameFixed(reader, header, data, bitsPerSample, order); } else { Debug.WriteLine($"Invalid Flac-SubframeType. SubframeType: 0x{subframeType:x}."); return(null); } if (hasWastedBits) { var destination = data.DestinationBuffer.Span; for (var i = 0; i < header.BlockSize; i++) { destination[i] <<= wastedBits; } } return(subFrame); } }
public unsafe FlacSubFrameLPC(FlacBitReader reader, FlacFrameHeader header, FlacSubFrameData data, int bitsPerSample, int order) : base(header) { var warmup = new int[order]; for (int i = 0; i < order; i++) { warmup[i] = data.ResidualBuffer[i] = reader.ReadBitsSigned(bitsPerSample); } int coefPrecision = (int)reader.ReadBits(4); if (coefPrecision == 0x0F) { throw new FlacException("Invalid \"quantized linear predictor coefficients' precision in bits\" was invalid. Must not be 0x0F.", FlacLayer.SubFrame); } coefPrecision += 1; int shiftNeeded = reader.ReadBitsSigned(5); if (shiftNeeded < 0) { throw new FlacException("'\"Quantized linear predictor coefficient shift needed in bits\" was negative.", FlacLayer.SubFrame); } var q = new int[order]; for (int i = 0; i < order; i++) { q[i] = reader.ReadBitsSigned(coefPrecision); } //decode the residual var residual = new FlacResidual(reader, header, data, order); for (int i = 0; i < order; i++) { data.DestinationBuffer[i] = data.ResidualBuffer[i]; } int *residualBuffer0 = data.ResidualBuffer + order; int *destinationBuffer0 = data.DestinationBuffer + order; int blockSizeToProcess = header.BlockSize - order; if (bitsPerSample + coefPrecision + Log2(order) <= 32) { RestoreLPCSignal32(residualBuffer0, destinationBuffer0, blockSizeToProcess, order, q, shiftNeeded); } else { RestoreLPCSignal64(residualBuffer0, destinationBuffer0, blockSizeToProcess, order, q, shiftNeeded); } #if FLAC_DEBUG QLPCoeffPrecision = coefPrecision; LPCShiftNeeded = shiftNeeded; Warmup = warmup; Residual = residual; QLPCoeffs = q; #endif }
private unsafe List<FlacFrameInformation> ScanThisShit(FlacMetadataStreamInfo streamInfo) { Stream stream = _stream; //if (!(stream is BufferedStream)) // stream = new BufferedStream(stream); byte[] buffer = new byte[BufferSize]; stream.Position = 4; //fLaC //skip the metadata FlacMetadata.SkipMetadata(stream); List<FlacFrameInformation> frames = new List<FlacFrameInformation>(); FlacFrameInformation frameInfo = new FlacFrameInformation(); frameInfo.IsFirstFrame = true; FlacFrameHeader baseHeader = null; while (true) { int read = stream.Read(buffer, 0, buffer.Length); if (read <= FlacConstant.FrameHeaderSize) break; fixed (byte* bufferPtr = buffer) { byte* ptr = bufferPtr; //for (int i = 0; i < read - FlacConstant.FrameHeaderSize; i++) while ((bufferPtr + read - FlacConstant.FrameHeaderSize) > ptr) { if (*ptr++ == 0xFF && (*ptr & 0xF8) == 0xF8) //check sync { byte* ptrSafe = ptr; ptr--; FlacFrameHeader tmp; if (IsFrame(ref ptr, streamInfo, out tmp)) { FlacFrameHeader header = tmp; if (frameInfo.IsFirstFrame) { baseHeader = header; frameInfo.IsFirstFrame = false; } if (baseHeader != null && baseHeader.IsFormatEqualTo(header)) { frameInfo.StreamOffset = stream.Position - read + ((ptrSafe - 1) - bufferPtr); frameInfo.Header = header; frames.Add(frameInfo); frameInfo.SampleOffset += header.BlockSize; } else { ptr = ptrSafe; } } else { ptr = ptrSafe; } } } } stream.Position -= FlacConstant.FrameHeaderSize; } return frames; }
public static unsafe FlacSubFrameBase GetSubFrame(FlacBitReader reader, FlacSubFrameData data, FlacFrameHeader header, int bps) { uint x; int wastedBits = 0, totalBits = 0, order = 0; x = reader.ReadBits(8); bool haswastedBits = (x & 1) != 0; x &= 0xFE; //1111 1110 if (haswastedBits) { int u = (int)reader.ReadUnary(); wastedBits = u + 1; bps -= wastedBits; totalBits = bps; } if ((x & 0x80) != 0) { Debug.WriteLine("Flacdecoder lost sync while reading FlacSubFrameHeader. [x & 0x80]."); return null; } FlacSubFrameBase subFrame = null; if ((x > 2 && x < 16) || (x > 24 && x < 64)) { Debug.WriteLine("Invalid FlacSubFrameHeader. [" + x.ToString("x") + "]"); return null; } else if (x == 0) { subFrame = new FlacSubFrameConstant(reader, header, data, bps); } else if (x == 2) { //verbatim subFrame = new FlacSubFrameVerbatim(reader, header, data, bps); } else if (x >= 16 && x <= 24) { //fixed order = (int)((x >> 1) & 7); subFrame = new FlacSubFrameFixed(reader, header, data, bps, order); } else if (x >= 64) { //lpc order = (int)(((x >> 1) & 31) + 1); subFrame = new FlacSubFrameLPC(reader, header, data, bps, order); } else { Debug.WriteLine("Invalid Flac-SubframeType: x = " + x + "."); return null; } if (haswastedBits) { int* ptrDest = data.destBuffer; for (int i = 0; i < header.BlockSize; i++) { *(ptrDest++) <<= wastedBits; } } //System.Diagnostics.Debug.WriteLine(subFrame.GetType().Name); if (subFrame != null) subFrame.WastedBits = wastedBits; else Debug.WriteLine("Unknown error while reading FlacSubFrameHeader"); return subFrame; }