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 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 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 IEnumerable<AudioChunk> StreamData( Stream source )
{
info = new AudioChunk();
PrimitiveReader reader = new PrimitiveReader( source );
while( true ) {
// Read frame header
BitReader bitReader = new BitReader( reader );
bitReader.BigEndian = true;
//Console.WriteLine( "start pos" + reader.Position );
// Skip any padding('00') bytes before the start of a frame
byte data = 0;
while( ( data = reader.ReadByte() ) == 0 );
// Make sure that the 'data' byte is the first 8 bits of the sync word.
if( data != 0xFF ) {
throw new InvalidDataException( "Invalid frame sync value." );
}
int frameSync = bitReader.ReadBits( 3/*11*/ );
if( frameSync != 0x7/*FF*/ ) {
throw new InvalidDataException( "Invalid frame sync value." );
}
int versionId = bitReader.ReadBits( 2 );
int layerIndex = bitReader.ReadBits( 2 );
bool crcProtection = bitReader.ReadBit() == 0;
int bitrateIndex = bitReader.ReadBits( 4 );
int samplingRateIndex = bitReader.ReadBits( 2 );
bool padded = bitReader.ReadBit() != 0;
int privateBit = bitReader.ReadBit();
int channelMode = bitReader.ReadBits( 2 );
int modeExtension = bitReader.ReadBits( 2 );
int copyrightBit = bitReader.ReadBit();
int originalBit = bitReader.ReadBit();
int emphasis = bitReader.ReadBits( 2 );
int bitrate = GetBitRate( (MpegVersion)versionId, layerIndex, bitrateIndex );
info.Frequency = samplingRates[versionId][samplingRateIndex];
ushort crc = 0;
if( crcProtection ) {
crc = (ushort)bitReader.ReadBits( 16 );
}
MpegFrame frame = new MpegFrame();
frame.Bitrate = bitrate;
frame.ChannelMode = (ChannelMode)channelMode;
frame.Channels = Common.GetNumberOfChannels( frame.ChannelMode );
frame.CrcProtected = crcProtection;
frame.Padding = padded;
frame.ModeExtension = modeExtension;
frame.SampleRate = info.Frequency;
frame.Emphasis = emphasis;
frame.Version = (MpegVersion)versionId;
LayerIndex index2 = (LayerIndex)layerIndex;
info.Data = null;
//Console.WriteLine( "padding: {0}, type: {1}, sr: {2}, br: {3}",
//frame.Padding, index2, frame.SampleRate, frame.Bitrate );
if( layerIndex == (int)LayerIndex.Layer1 ) {
info.Data = decoder1.Decode( frame, bitReader );
} else if( layerIndex == (int)LayerIndex.Layer2 ) {
info.Data = decoder2.Decode( frame, bitReader );
} else if( layerIndex == (int)LayerIndex.Layer3 ) {
throw new NotSupportedException( "Layer III not supported" );
} else {
throw new InvalidDataException( "Invalid layer" );
}
info.Channels = frame.Channels;
info.BitsPerSample = 16;
//if( bitReader.offset == 8 ) {
//reader.ReadByte();
//}
yield return info;
}
}
public override void ReadSetupData( VorbisCodec codec, BitReader reader )
{
int syncPattern = reader.ReadBits( 24 );
if( syncPattern != 0x564342 ) {
throw new InvalidDataException( "Invalid codebook sync pattern: " + syncPattern );
}
int dimensions = reader.ReadBits( 16 );
int entries = reader.ReadBits( 24 );
int ordered = reader.ReadBit();
codewordLengths = new byte[entries];
if( ordered == 0 ) {
int sparse = reader.ReadBit();
for( int i = 0; i < entries; i++ ) {
if( sparse == 0 || ( reader.ReadBit() == 1 ) ) {
codewordLengths[i] = (byte)( reader.ReadBits( 5 ) + 1 );
}
}
} else {
int curEntry = 0;
int curLength = reader.ReadBits( 5 ) + 1;
while( curEntry < entries ) {
int number = reader.ReadBits( VorbisUtils.iLog( entries - curEntry ) );
for( int i = curEntry; i < curEntry + number; i++ ) {
codewordLengths[i] = (byte)curLength;
}
curEntry += number;
curLength++;
}
}
BuildHuffmanTree();
int lookupType = reader.ReadBits( 4 );
if( lookupType == 1 || lookupType == 2 ) {
float minValue = VorbisUtils.Unpack( reader.ReadBitsU( 32 ) );
float deltaValue = VorbisUtils.Unpack( reader.ReadBitsU( 32 ) );
int valueBits = reader.ReadBits( 4 ) + 1;
int sequenceP = reader.ReadBit();
int lookupValues = 0;
if( lookupType == 1 ) {
lookupValues = VorbisUtils.lookup1_values( entries, dimensions );
} else {
lookupValues = entries * dimensions;
}
multiplicands = new ushort[lookupValues];
for( int i = 0; i < multiplicands.Length; i++ ) {
multiplicands[i] = (ushort)reader.ReadBits( valueBits );
}
VQ = new float[entries][];
for( int i = 0; i < entries; i++ ) {
float[] vector = new float[dimensions];
if( lookupType == 1 ) {
float last = 0;
int indexDivisor = 1;
for( int j = 0; j < dimensions; j++ ) {
int multiplicandOffset = ( i / indexDivisor ) % lookupValues;
vector[j] = multiplicands[multiplicandOffset] * deltaValue + minValue + last;
if( sequenceP != 0 ) last = vector[j];
indexDivisor *= lookupValues;
}
} else {
float last = 0;
int mulitiplicandOffset = i * dimensions;
for( int j = 0; j < dimensions; j++ ) {
vector[j] = multiplicands[mulitiplicandOffset] * deltaValue + minValue + last;
if( sequenceP != 0 ) last = vector[j];
mulitiplicandOffset++;
}
}
VQ[i] = vector;
}
}
}
