// Get the current sample index position, or -1 if unknown
internal static long WavpackGetSampleIndex(WavpackContext wpc)
{
if (null != wpc)
{
return(wpc.stream.sample_index);
}
return((long)(-1));
}
// Returns the number of bytes used for each sample (1 to 4) in the original
// file. This is required information for the user of this module because the
// audio data is returned in the LOWER bytes of the long buffer and must be
// left-shifted 8, 16, or 24 bits if normalized longs are required.
internal static int WavpackGetBytesPerSample(WavpackContext wpc)
{
if (null != wpc && wpc.config.bytes_per_sample != 0)
{
return(wpc.config.bytes_per_sample);
}
else
{
return(2);
}
}
// Returns the number of channels of the specified WavPack file. Note that
// this is the actual number of channels contained in the file, but this
// version can only decode the first two.
internal static int WavpackGetNumChannels(WavpackContext wpc)
{
if (null != wpc && wpc.config.num_channels != 0)
{
return(wpc.config.num_channels);
}
else
{
return(2);
}
}
// Returns the sample rate of the specified WavPack file
internal static long WavpackGetSampleRate(WavpackContext wpc)
{
if (null != wpc && wpc.config.sample_rate != 0)
{
return(wpc.config.sample_rate);
}
else
{
return((long)44100);
}
}
// return if any uncorrected lossy blocks were actually written or read
internal static int WavpackLossyBlocks(WavpackContext wpc)
{
if (null != wpc)
{
return(wpc.lossy_blocks);
}
else
{
return(0);
}
}
// Get the number of errors encountered so far
internal static long WavpackGetNumErrors(WavpackContext wpc)
{
if (null != wpc)
{
return(wpc.crc_errors);
}
else
{
return((long)0);
}
}
// The following seek functionality has not yet been extensively tested
public static void setTime(WavpackContext wpc, long milliseconds)
{
long targetSample = (long)(milliseconds / 1000 * wpc.config.sample_rate);
try
{
seek(wpc, wpc.infile, wpc.infile.BaseStream.Position, targetSample);
}
catch (System.IO.IOException)
{
}
}
// Get total number of samples contained in the WavPack file, or -1 if unknown
internal static long WavpackGetNumSamples(WavpackContext wpc)
{
// -1 would mean an unknown number of samples
if (null != wpc)
{
return(wpc.total_samples);
}
else
{
return((long)(-1));
}
}
// This function obtains general information about an open file and returns
// a mask with the following bit values:
// MODE_LOSSLESS: file is lossless (pure lossless only)
// MODE_HYBRID: file is hybrid mode (lossy part only)
// MODE_FLOAT: audio data is 32-bit ieee floating point (but will provided
// in 24-bit integers for convenience)
// MODE_HIGH: file was created in "high" mode (information only)
// MODE_FAST: file was created in "fast" mode (information only)
internal static int WavpackGetMode(WavpackContext wpc)
{
int mode = 0;
if (null != wpc)
{
if ((wpc.config.flags & Defines.CONFIG_HYBRID_FLAG) != 0)
{
mode |= Defines.MODE_HYBRID;
}
else if ((wpc.config.flags & Defines.CONFIG_LOSSY_MODE) == 0)
{
mode |= Defines.MODE_LOSSLESS;
}
if (wpc.lossy_blocks != 0)
{
mode &= ~Defines.MODE_LOSSLESS;
}
if ((wpc.config.flags & Defines.CONFIG_FLOAT_DATA) != 0)
{
mode |= Defines.MODE_FLOAT;
}
if ((wpc.config.flags & Defines.CONFIG_HIGH_FLAG) != 0)
{
mode |= Defines.MODE_HIGH;
}
if ((wpc.config.flags & Defines.CONFIG_FAST_FLAG) != 0)
{
mode |= Defines.MODE_FAST;
}
}
return(mode);
}
public static void Main(System.String[] args)
{
ChunkHeader FormatChunkHeader = new ChunkHeader();
ChunkHeader DataChunkHeader = new ChunkHeader();
RiffChunkHeader myRiffChunkHeader = new RiffChunkHeader();
WaveHeader WaveHeader = new WaveHeader();
sbyte[] myRiffChunkHeaderAsByteArray = new sbyte[12];
sbyte[] myFormatChunkHeaderAsByteArray = new sbyte[8];
sbyte[] myWaveHeaderAsByteArray = new sbyte[16];
sbyte[] myDataChunkHeaderAsByteArray = new sbyte[8];
long total_unpacked_samples = 0, total_samples; // was uint32_t in C
int num_channels, bps;
WavpackContext wpc = new WavpackContext();
System.IO.FileStream fistream;
System.IO.FileStream fostream;
System.IO.BinaryReader in_Renamed;
long start, end;
System.String inputWVFile;
if (args.Length == 0)
{
inputWVFile = "input.wv";
}
else
{
inputWVFile = args[0];
}
try
{
fistream = new System.IO.FileStream(inputWVFile, System.IO.FileMode.Open, System.IO.FileAccess.Read);
System.IO.BufferedStream bstream = new System.IO.BufferedStream(fistream, 16384);
in_Renamed = new System.IO.BinaryReader(bstream);
wpc = WavPackUtils.WavpackOpenFileInput(in_Renamed);
}
catch (System.IO.FileNotFoundException)
{
System.Console.Error.WriteLine("Input file not found");
System.Environment.Exit(1);
}
catch (System.IO.DirectoryNotFoundException)
{
System.Console.Error.WriteLine("Input file not found - invalid directory");
System.Environment.Exit(1);
}
if (wpc.error)
{
System.Console.Error.WriteLine("Sorry an error has occured");
System.Console.Error.WriteLine(wpc.error_message);
System.Environment.Exit(1);
}
num_channels = WavPackUtils.WavpackGetReducedChannels(wpc);
System.Console.Out.WriteLine("The WavPack file has " + num_channels + " channels");
total_samples = WavPackUtils.WavpackGetNumSamples(wpc);
System.Console.Out.WriteLine("The WavPack file has " + total_samples + " samples");
bps = WavPackUtils.WavpackGetBytesPerSample(wpc);
System.Console.Out.WriteLine("The WavPack file has " + bps + " bytes per sample");
myRiffChunkHeader.ckID[0] = 'R';
myRiffChunkHeader.ckID[1] = 'I';
myRiffChunkHeader.ckID[2] = 'F';
myRiffChunkHeader.ckID[3] = 'F';
myRiffChunkHeader.ckSize = total_samples * num_channels * bps + 8 * 2 + 16 + 4;
myRiffChunkHeader.formType[0] = 'W';
myRiffChunkHeader.formType[1] = 'A';
myRiffChunkHeader.formType[2] = 'V';
myRiffChunkHeader.formType[3] = 'E';
FormatChunkHeader.ckID[0] = 'f';
FormatChunkHeader.ckID[1] = 'm';
FormatChunkHeader.ckID[2] = 't';
FormatChunkHeader.ckID[3] = ' ';
FormatChunkHeader.ckSize = 16;
WaveHeader.FormatTag = 1;
WaveHeader.NumChannels = num_channels;
WaveHeader.SampleRate = WavPackUtils.WavpackGetSampleRate(wpc);
WaveHeader.BlockAlign = num_channels * bps;
WaveHeader.BytesPerSecond = WaveHeader.SampleRate * WaveHeader.BlockAlign;
WaveHeader.BitsPerSample = WavPackUtils.WavpackGetBitsPerSample(wpc);
DataChunkHeader.ckID[0] = 'd';
DataChunkHeader.ckID[1] = 'a';
DataChunkHeader.ckID[2] = 't';
DataChunkHeader.ckID[3] = 'a';
DataChunkHeader.ckSize = total_samples * num_channels * bps;
myRiffChunkHeaderAsByteArray[0] = (sbyte)myRiffChunkHeader.ckID[0];
myRiffChunkHeaderAsByteArray[1] = (sbyte)myRiffChunkHeader.ckID[1];
myRiffChunkHeaderAsByteArray[2] = (sbyte)myRiffChunkHeader.ckID[2];
myRiffChunkHeaderAsByteArray[3] = (sbyte)myRiffChunkHeader.ckID[3];
// swap endians here
myRiffChunkHeaderAsByteArray[7] = (sbyte)(SupportClass.URShift(myRiffChunkHeader.ckSize, 24));
myRiffChunkHeaderAsByteArray[6] = (sbyte)(SupportClass.URShift(myRiffChunkHeader.ckSize, 16));
myRiffChunkHeaderAsByteArray[5] = (sbyte)(SupportClass.URShift(myRiffChunkHeader.ckSize, 8));
myRiffChunkHeaderAsByteArray[4] = (sbyte)(myRiffChunkHeader.ckSize);
myRiffChunkHeaderAsByteArray[8] = (sbyte)myRiffChunkHeader.formType[0];
myRiffChunkHeaderAsByteArray[9] = (sbyte)myRiffChunkHeader.formType[1];
myRiffChunkHeaderAsByteArray[10] = (sbyte)myRiffChunkHeader.formType[2];
myRiffChunkHeaderAsByteArray[11] = (sbyte)myRiffChunkHeader.formType[3];
myFormatChunkHeaderAsByteArray[0] = (sbyte)FormatChunkHeader.ckID[0];
myFormatChunkHeaderAsByteArray[1] = (sbyte)FormatChunkHeader.ckID[1];
myFormatChunkHeaderAsByteArray[2] = (sbyte)FormatChunkHeader.ckID[2];
myFormatChunkHeaderAsByteArray[3] = (sbyte)FormatChunkHeader.ckID[3];
// swap endians here
myFormatChunkHeaderAsByteArray[7] = (sbyte)(SupportClass.URShift(FormatChunkHeader.ckSize, 24));
myFormatChunkHeaderAsByteArray[6] = (sbyte)(SupportClass.URShift(FormatChunkHeader.ckSize, 16));
myFormatChunkHeaderAsByteArray[5] = (sbyte)(SupportClass.URShift(FormatChunkHeader.ckSize, 8));
myFormatChunkHeaderAsByteArray[4] = (sbyte)(FormatChunkHeader.ckSize);
// swap endians
myWaveHeaderAsByteArray[1] = (sbyte)(SupportClass.URShift(WaveHeader.FormatTag, 8));
myWaveHeaderAsByteArray[0] = (sbyte)(WaveHeader.FormatTag);
// swap endians
myWaveHeaderAsByteArray[3] = (sbyte)(SupportClass.URShift(WaveHeader.NumChannels, 8));
myWaveHeaderAsByteArray[2] = (sbyte)WaveHeader.NumChannels;
// swap endians
myWaveHeaderAsByteArray[7] = (sbyte)(SupportClass.URShift(WaveHeader.SampleRate, 24));
myWaveHeaderAsByteArray[6] = (sbyte)(SupportClass.URShift(WaveHeader.SampleRate, 16));
myWaveHeaderAsByteArray[5] = (sbyte)(SupportClass.URShift(WaveHeader.SampleRate, 8));
myWaveHeaderAsByteArray[4] = (sbyte)(WaveHeader.SampleRate);
// swap endians
myWaveHeaderAsByteArray[11] = (sbyte)(SupportClass.URShift(WaveHeader.BytesPerSecond, 24));
myWaveHeaderAsByteArray[10] = (sbyte)(SupportClass.URShift(WaveHeader.BytesPerSecond, 16));
myWaveHeaderAsByteArray[9] = (sbyte)(SupportClass.URShift(WaveHeader.BytesPerSecond, 8));
myWaveHeaderAsByteArray[8] = (sbyte)(WaveHeader.BytesPerSecond);
// swap endians
myWaveHeaderAsByteArray[13] = (sbyte)(SupportClass.URShift(WaveHeader.BlockAlign, 8));
myWaveHeaderAsByteArray[12] = (sbyte)WaveHeader.BlockAlign;
// swap endians
myWaveHeaderAsByteArray[15] = (sbyte)(SupportClass.URShift(WaveHeader.BitsPerSample, 8));
myWaveHeaderAsByteArray[14] = (sbyte)WaveHeader.BitsPerSample;
myDataChunkHeaderAsByteArray[0] = (sbyte)DataChunkHeader.ckID[0];
myDataChunkHeaderAsByteArray[1] = (sbyte)DataChunkHeader.ckID[1];
myDataChunkHeaderAsByteArray[2] = (sbyte)DataChunkHeader.ckID[2];
myDataChunkHeaderAsByteArray[3] = (sbyte)DataChunkHeader.ckID[3];
// swap endians
myDataChunkHeaderAsByteArray[7] = (sbyte)(SupportClass.URShift(DataChunkHeader.ckSize, 24));
myDataChunkHeaderAsByteArray[6] = (sbyte)(SupportClass.URShift(DataChunkHeader.ckSize, 16));
myDataChunkHeaderAsByteArray[5] = (sbyte)(SupportClass.URShift(DataChunkHeader.ckSize, 8));
myDataChunkHeaderAsByteArray[4] = (sbyte)DataChunkHeader.ckSize;
try
{
fostream = new System.IO.FileStream("output.wav", System.IO.FileMode.Create);
SupportClass.WriteOutput(fostream, myRiffChunkHeaderAsByteArray);
SupportClass.WriteOutput(fostream, myFormatChunkHeaderAsByteArray);
SupportClass.WriteOutput(fostream, myWaveHeaderAsByteArray);
SupportClass.WriteOutput(fostream, myDataChunkHeaderAsByteArray);
start = (System.DateTime.Now.Ticks - 621355968000000000) / 10000;
while (true)
{
long samples_unpacked; // was uint32_t in C
samples_unpacked = WavPackUtils.WavpackUnpackSamples(wpc, temp_buffer, Defines.SAMPLE_BUFFER_SIZE / num_channels);
total_unpacked_samples += samples_unpacked;
if (samples_unpacked > 0)
{
samples_unpacked = samples_unpacked * num_channels;
pcm_buffer = format_samples(bps, temp_buffer, samples_unpacked);
fostream.Write(pcm_buffer, 0, (int)samples_unpacked * bps);
}
if (samples_unpacked == 0)
{
break;
}
} // end of while
end = (System.DateTime.Now.Ticks - 621355968000000000) / 10000;
System.Console.Out.WriteLine(end - start + " milli seconds to process WavPack file in main loop");
}
catch (System.Exception e)
{
System.Console.Error.WriteLine("Error when writing wav file, sorry: ");
SupportClass.WriteStackTrace(e, Console.Error);
System.Environment.Exit(1);
}
if ((WavPackUtils.WavpackGetNumSamples(wpc) != -1) && (total_unpacked_samples != WavPackUtils.WavpackGetNumSamples(wpc)))
{
System.Console.Error.WriteLine("Incorrect number of samples");
System.Environment.Exit(1);
}
if (WavPackUtils.WavpackGetNumErrors(wpc) > 0)
{
System.Console.Error.WriteLine("CRC errors detected");
System.Environment.Exit(1);
}
System.Environment.Exit(0);
}
// Find the WavPack block that contains the specified sample. If "header_pos"
// is zero, then no information is assumed except the total number of samples
// in the file and its size in bytes. If "header_pos" is non-zero then we
// assume that it is the file position of the valid header image contained in
// the first stream and we can limit our search to either the portion above
// or below that point. If a .wvc file is being used, then this must be called
// for that file also.
private static void seek(WavpackContext wpc, System.IO.BinaryReader infile, long headerPos, long targetSample)
{
try
{
WavpackStream wps = wpc.stream;
long file_pos1 = 0;
long file_pos2 = wpc.infile.BaseStream.Length;
long sample_pos1 = 0, sample_pos2 = wpc.total_samples;
double ratio = 0.96;
int file_skip = 0;
if (targetSample >= wpc.total_samples)
{
return;
}
if (headerPos > 0 && wps.wphdr.block_samples > 0)
{
if (wps.wphdr.block_index > targetSample)
{
sample_pos2 = wps.wphdr.block_index;
file_pos2 = headerPos;
}
else if (wps.wphdr.block_index + wps.wphdr.block_samples <= targetSample)
{
sample_pos1 = wps.wphdr.block_index;
file_pos1 = headerPos;
}
else
{
return;
}
}
while (true)
{
double bytes_per_sample;
long seek_pos;
bytes_per_sample = file_pos2 - file_pos1;
bytes_per_sample /= sample_pos2 - sample_pos1;
seek_pos = file_pos1 + (file_skip > 0 ? 32 : 0);
seek_pos += (long)(bytes_per_sample * (targetSample - sample_pos1) * ratio);
infile.BaseStream.Seek(seek_pos, 0);
long temppos = infile.BaseStream.Position;
wps.wphdr = read_next_header(infile, wps.wphdr);
if (wps.wphdr.status == 1 || seek_pos >= file_pos2)
{
if (ratio > 0.0)
{
if ((ratio -= 0.24) < 0.0)
{
ratio = 0.0;
}
}
else
{
return;
}
}
else if (wps.wphdr.block_index > targetSample)
{
sample_pos2 = wps.wphdr.block_index;
file_pos2 = seek_pos;
}
else if (wps.wphdr.block_index + wps.wphdr.block_samples <= targetSample)
{
if (seek_pos == file_pos1)
{
file_skip = 1;
}
else
{
sample_pos1 = wps.wphdr.block_index;
file_pos1 = seek_pos;
}
}
else
{
int index = (int)(targetSample - wps.wphdr.block_index);
infile.BaseStream.Seek(seek_pos, 0);
WavpackContext c = WavpackOpenFileInput(infile);
wpc.stream = c.stream;
int[] temp_buf = new int[Defines.SAMPLE_BUFFER_SIZE];
while (index > 0)
{
int toUnpack = Math.Min(index, Defines.SAMPLE_BUFFER_SIZE / WavpackGetReducedChannels(wpc));
WavpackUnpackSamples(wpc, temp_buf, toUnpack);
index = index - toUnpack;
}
return;
}
}
}
catch (System.IO.IOException)
{
}
}
public static void setSample(WavpackContext wpc, long sample)
{
seek(wpc, wpc.infile, 0, sample);
}
///////////////////////////// executable code ////////////////////////////////
// This function reads data from the specified stream in search of a valid
// WavPack 4.0 audio block. If this fails in 1 megabyte (or an invalid or
// unsupported WavPack block is encountered) then an appropriate message is
// copied to "error" and NULL is returned, otherwise a pointer to a
// WavpackContext structure is returned (which is used to call all other
// functions in this module). This can be initiated at the beginning of a
// WavPack file, or anywhere inside a WavPack file. To determine the exact
// position within the file use WavpackGetSampleIndex(). Also,
// this function will not handle "correction" files, plays only the first
// two channels of multi-channel files, and is limited in resolution in some
// large integer or floating point files (but always provides at least 24 bits
// of resolution).
public static WavpackContext WavpackOpenFileInput(System.IO.BinaryReader infile)
{
WavpackContext wpc = new WavpackContext();
WavpackStream wps = wpc.stream;
wpc.infile = infile;
wpc.total_samples = -1;
wpc.norm_offset = 0;
wpc.open_flags = 0;
// open the source file for reading and store the size
while (wps.wphdr.block_samples == 0)
{
wps.wphdr = read_next_header(wpc.infile, wps.wphdr);
if (wps.wphdr.status == 1)
{
wpc.error_message = "not compatible with this version of WavPack file!";
wpc.error = true;
return(wpc);
}
if (wps.wphdr.block_samples > 0 && wps.wphdr.total_samples != -1)
{
wpc.total_samples = wps.wphdr.total_samples;
}
// lets put the stream back in the context
wpc.stream = wps;
if ((UnpackUtils.unpack_init(wpc)) == Defines.FALSE)
{
wpc.error = true;
return(wpc);
}
} // end of while
wpc.config.flags = wpc.config.flags & ~0xff;
wpc.config.flags = wpc.config.flags | (wps.wphdr.flags & 0xff);
wpc.config.bytes_per_sample = (int)((wps.wphdr.flags & Defines.BYTES_STORED) + 1);
wpc.config.float_norm_exp = wps.float_norm_exp;
wpc.config.bits_per_sample = (int)((wpc.config.bytes_per_sample * 8) - ((wps.wphdr.flags & Defines.SHIFT_MASK) >> Defines.SHIFT_LSB));
if ((wpc.config.flags & Defines.FLOAT_DATA) > 0)
{
wpc.config.bytes_per_sample = 3;
wpc.config.bits_per_sample = 24;
}
if (wpc.config.sample_rate == 0)
{
if (wps.wphdr.block_samples == 0 || (wps.wphdr.flags & Defines.SRATE_MASK) == Defines.SRATE_MASK)
{
wpc.config.sample_rate = 44100;
}
else
{
wpc.config.sample_rate = sample_rates[(int)((wps.wphdr.flags & Defines.SRATE_MASK) >> Defines.SRATE_LSB)];
}
}
if (wpc.config.num_channels == 0)
{
if ((wps.wphdr.flags & Defines.MONO_FLAG) > 0)
{
wpc.config.num_channels = 1;
}
else
{
wpc.config.num_channels = 2;
}
wpc.config.channel_mask = 0x5 - wpc.config.num_channels;
}
if ((wps.wphdr.flags & Defines.FINAL_BLOCK) == 0)
{
if ((wps.wphdr.flags & Defines.MONO_FLAG) != 0)
{
wpc.reduced_channels = 1;
}
else
{
wpc.reduced_channels = 2;
}
}
return(wpc);
}
// Unpack the specified number of samples from the current file position.
// Note that "samples" here refers to "complete" samples, which would be
// 2 longs for stereo files. The audio data is returned right-justified in
// 32-bit longs in the endian mode native to the executing processor. So,
// if the original data was 16-bit, then the values returned would be
// +/-32k. Floating point data will be returned as 24-bit integers (and may
// also be clipped). The actual number of samples unpacked is returned,
// which should be equal to the number requested unless the end of fle is
// encountered or an error occurs.
internal static long WavpackUnpackSamples(WavpackContext wpc, int[] buffer, long samples)
{
WavpackStream wps = wpc.stream;
long samples_unpacked = 0, samples_to_unpack;
int num_channels = wpc.config.num_channels;
int bcounter = 0;
int buf_idx = 0;
int bytes_returned = 0;
while (samples > 0)
{
if (wps.wphdr.block_samples == 0 || (wps.wphdr.flags & Defines.INITIAL_BLOCK) == 0 || wps.sample_index >= wps.wphdr.block_index + wps.wphdr.block_samples)
{
wps.wphdr = read_next_header(wpc.infile, wps.wphdr);
if (wps.wphdr.status == 1)
{
break;
}
if (wps.wphdr.block_samples == 0 || wps.sample_index == wps.wphdr.block_index)
{
if ((UnpackUtils.unpack_init(wpc)) == Defines.FALSE)
{
break;
}
}
}
if (wps.wphdr.block_samples == 0 || (wps.wphdr.flags & Defines.INITIAL_BLOCK) == 0 || wps.sample_index >= wps.wphdr.block_index + wps.wphdr.block_samples)
{
continue;
}
if (wps.sample_index < wps.wphdr.block_index)
{
samples_to_unpack = wps.wphdr.block_index - wps.sample_index;
if (samples_to_unpack > samples)
{
samples_to_unpack = samples;
}
wps.sample_index += samples_to_unpack;
samples_unpacked += samples_to_unpack;
samples -= samples_to_unpack;
if (wpc.reduced_channels > 0)
{
samples_to_unpack *= wpc.reduced_channels;
}
else
{
samples_to_unpack *= num_channels;
}
bcounter = buf_idx;
while (samples_to_unpack > 0)
{
buffer[bcounter] = 0;
bcounter++;
samples_to_unpack--;
}
buf_idx = bcounter;
continue;
}
samples_to_unpack = wps.wphdr.block_index + wps.wphdr.block_samples - wps.sample_index;
if (samples_to_unpack > samples)
{
samples_to_unpack = samples;
}
UnpackUtils.unpack_samples(wpc, buffer, samples_to_unpack, buf_idx);
if (wpc.reduced_channels > 0)
{
bytes_returned = (int)(samples_to_unpack * wpc.reduced_channels);
}
else
{
bytes_returned = (int)(samples_to_unpack * num_channels);
}
buf_idx += bytes_returned;
samples_unpacked += samples_to_unpack;
samples -= samples_to_unpack;
if (wps.sample_index == wps.wphdr.block_index + wps.wphdr.block_samples)
{
if (UnpackUtils.check_crc_error(wpc) > 0)
{
wpc.crc_errors++;
}
}
if (wps.sample_index == wpc.total_samples)
{
break;
}
}
return(samples_unpacked);
}
internal static int read_metadata_buff(WavpackContext wpc, WavpackMetadata wpmd)
{
long bytes_to_read;
short tchar;
if (wpmd.bytecount >= wpc.stream.wphdr.ckSize)
{
// we have read all the data in this block
return(Defines.FALSE);
}
try
{
wpmd.id = (short)wpc.infile.ReadByte();
tchar = (short)wpc.infile.ReadByte();
}
catch (System.Exception)
{
wpmd.status = 1;
return(Defines.FALSE);
}
wpmd.bytecount += 2;
wpmd.byte_length = tchar << 1;
if ((wpmd.id & Defines.ID_LARGE) != 0)
{
wpmd.id &= (short)~Defines.ID_LARGE;
try
{
tchar = (short)wpc.infile.ReadByte();
}
catch (System.Exception)
{
wpmd.status = 1;
return(Defines.FALSE);
}
wpmd.byte_length += ((int)tchar << 9);
try
{
tchar = (short)wpc.infile.ReadByte();
}
catch (System.Exception)
{
wpmd.status = 1;
return(Defines.FALSE);
}
wpmd.byte_length += ((int)tchar << 17);
wpmd.bytecount += 2;
}
if ((wpmd.id & Defines.ID_ODD_SIZE) != 0)
{
wpmd.id &= (short)~Defines.ID_ODD_SIZE;
wpmd.byte_length--;
}
if (wpmd.byte_length == 0 || wpmd.id == Defines.ID_WV_BITSTREAM)
{
wpmd.hasdata = Defines.FALSE;
return(Defines.TRUE);
}
bytes_to_read = wpmd.byte_length + (wpmd.byte_length & 1);
wpmd.bytecount += bytes_to_read;
if (bytes_to_read > wpc.read_buffer.Length)
{
int bytes_read;
wpmd.hasdata = Defines.FALSE;
while (bytes_to_read > wpc.read_buffer.Length)
{
try
{
bytes_read = wpc.infile.BaseStream.Read(wpc.read_buffer, 0, wpc.read_buffer.Length);
if (bytes_read != wpc.read_buffer.Length)
{
return(Defines.FALSE);
}
}
catch (System.Exception)
{
return(Defines.FALSE);
}
bytes_to_read -= wpc.read_buffer.Length;
}
}
else
{
wpmd.hasdata = Defines.TRUE;
wpmd.data = wpc.read_buffer;
}
if (bytes_to_read != 0)
{
int bytes_read;
try
{
bytes_read = wpc.infile.BaseStream.Read(wpc.read_buffer, 0, (int)bytes_to_read);
if (bytes_read != (int)bytes_to_read)
{
wpmd.hasdata = Defines.FALSE;
return(Defines.FALSE);
}
}
catch (System.Exception)
{
wpmd.hasdata = Defines.FALSE;
return(Defines.FALSE);
}
}
return(Defines.TRUE);
}
internal static int process_metadata(WavpackContext wpc, WavpackMetadata wpmd)
{
WavpackStream wps = wpc.stream;
switch (wpmd.id)
{
case Defines.ID_DUMMY:
{
return(Defines.TRUE);
}
case Defines.ID_DECORR_TERMS:
{
return(UnpackUtils.read_decorr_terms(wps, wpmd));
}
case Defines.ID_DECORR_WEIGHTS:
{
return(UnpackUtils.read_decorr_weights(wps, wpmd));
}
case Defines.ID_DECORR_SAMPLES:
{
return(UnpackUtils.read_decorr_samples(wps, wpmd));
}
case Defines.ID_ENTROPY_VARS:
{
return(WordsUtils.read_entropy_vars(wps, wpmd));
}
case Defines.ID_HYBRID_PROFILE:
{
return(WordsUtils.read_hybrid_profile(wps, wpmd));
}
case Defines.ID_FLOAT_INFO:
{
return(FloatUtils.read_float_info(wps, wpmd));
}
case Defines.ID_INT32_INFO:
{
return(UnpackUtils.read_int32_info(wps, wpmd));
}
case Defines.ID_CHANNEL_INFO:
{
return(UnpackUtils.read_channel_info(wpc, wpmd));
}
case Defines.ID_SAMPLE_RATE:
{
return(UnpackUtils.read_sample_rate(wpc, wpmd));
}
case Defines.ID_CONFIG_BLOCK:
{
return(UnpackUtils.read_config_info(wpc, wpmd));
}
case Defines.ID_WV_BITSTREAM:
{
return(UnpackUtils.init_wv_bitstream(wpc, wpmd));
}
case Defines.ID_SHAPING_WEIGHTS:
case Defines.ID_WVC_BITSTREAM:
case Defines.ID_WVX_BITSTREAM:
{
return(Defines.TRUE);
}
default:
{
if ((wpmd.id & Defines.ID_OPTIONAL_DATA) != 0)
{
return(Defines.TRUE);
}
else
{
return(Defines.FALSE);
}
}
break;
}
}