Odczyt wava w C#

Witam!

Mam nastepujacy problem probuje odczytac dane z pliku wave i odczytujac nagłówek wszystko jest OK, ale jezeli probuje odczytac dane dotyczce juz samego sygnalu pojawia sie problem, gdy jest to wave 16 bitowy to probki sa zapisane w 2 bajtach i probuje je odczytac do jakiegos typu 2 bajktowego ze znakiem, no i np jest to Int16 ale uzyskiwane liczby w ten sposob sa jakies abstrakcyjne, gdyz liczby powinny byc mniejwiecej z zakresu od -32 do 32, i nie wiem co z tym fantem zrobic

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using Microsoft.DirectX.DirectSound;


namespace Zabawa_z_wav_em
{
    public partial class Form1 : Form
    {
        private string big_endian(BinaryReader reader, int ile) // funkcyjka czyta 4 znaki i zamienia z binarnego na ascii
        {
            byte[] ch = new byte[ile];
            reader.Read(ch, 0, ch.Length);
           
            return Encoding.ASCII.GetString(ch, 0, ch.Length);
        }
        private string little_endian(BinaryReader reader, int ile) // funkcyjka czyta 4 znaki i zamienia z binarnego na ascii
        {            
            byte[] temp = new byte[ile];
            reader.Read(temp, 0, temp.Length);
            
            int t;
            if (ile == 4)
            {
                t = BitConverter.ToInt32(temp, 0);
                
            }
            else
                t = BitConverter.ToInt16(temp, 0);

            return t.ToString();
        }

        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            OpenFileDialog op = new OpenFileDialog();
            op.Title = "Otwieranie pliku wave";
            op.InitialDirectory = "C:\\Users\\Sylwuś\\Desktop";
            op.Filter = "Pliki wav |*.wav";
            op.ShowDialog();
            
            byte[] tab1;
            short[] tab2;
            

            try
            {
                op.OpenFile();
                FileStream file = new FileStream(op.FileName, FileMode.Open, FileAccess.Read);
                BinaryReader reader = new BinaryReader(file);
                textBox1.Text = op.FileName.ToString();
                
                if (big_endian(reader,4) != "RIFF")			// czy to jest plik RIFF
                {
                    MessageBox.Show("To nie jest plik RIFF");
                    //throw new RiffParserException("To nie jest plik RIFF");

                }
                else
                {

                    textBox3.Text = little_endian(reader, 4);
                    textBox2.Text = big_endian(reader, 4);

                    reader.ReadBytes(8);
                    int rodzaj_kompresji;
                    rodzaj_kompresji = Convert.ToInt16(little_endian(reader, 2));

                    if (rodzaj_kompresji == 1 || rodzaj_kompresji==-1)
                        textBox4.Text = "Brak kompresji";
                    else
                    {
                        if (rodzaj_kompresji == 2 || rodzaj_kompresji==-2)
                            textBox4.Text = "Kompresja PCM";
                        else
                            textBox4.Text = rodzaj_kompresji.ToString();
                    }
                    int kanaly;
                    kanaly=Convert.ToInt32(little_endian(reader, 2));
                    if (kanaly == 1)
                        textBox5.Text = "MONO";
                    else
                    {
                        if (kanaly == 2)
                            textBox5.Text = "STEREO";
                        else
                            textBox5.Text = kanaly.ToString();
                    }
                    textBox6.Text = little_endian(reader, 4);
                    reader.ReadBytes(4);
                    textBox7.Text = little_endian(reader, 2);
                    textBox8.Text = little_endian(reader, 2);

                    int rozdzielczosc = Convert.ToInt32(textBox8.Text);

                    if (rozdzielczosc == 8)
                    {
                        tab1 = new byte[Convert.ToInt32(textBox3.Text)];
                        reader.ReadBytes(4);
                        tab1 = reader.ReadBytes(Convert.ToInt32(textBox3.Text));
                       
                    }
                    if (rozdzielczosc == 16)
                    {
                        tab2 = new short[Convert.ToInt32(textBox3.Text)/2];
                        reader.ReadBytes(4);

                        for (int i = 0; i < tab2.Length; i++)
                        {
                            tab2[i] = reader.ReadInt16();
                            MessageBox.Show(tab2[i].ToString());
                        }
                    }

                    int ii;

                    file.Close();
                }

            }
            catch 
            {
                MessageBox.Show("Dupa");
            }
            
            
        }
        
    }
}

Pozdrwawiam

Plik wave może mieć pomiędzy blokami FMT a DATA bloki opcjonalne, a nie widzę żebyś je jakoś "wyrzucał" (mogę być slepawy, uświadom mnie jeśli tak ;])
Mam kod do wczytania wave w MC++ jeśli cię urządza:

void PlikWave::WczytajPlik(System::String ^nazwaPliku)
{
BinaryReader ^Strumien = gcnew BinaryReader(File::Open(nazwaPliku, FileMode::Open));
	try
	{	
		//wczytanie do RiffChunkID 4 bajtów
		Strumien->Read(riff.RiffChunkID, 0, 4);
		//jeśli RiffChunkID nierówne "Riff" to wyrzucenie wyjątku
		if(String::Compare(this->DoString(riff.RiffChunkID), "RIFF") != 0)
				throw gcnew Exception("Niepoprawne pole RiffChunkID");
		//wczytanie 4 bajtów do RiffChunkSize
		riff.RiffChunkSize = Strumien->ReadInt32();
		//wczytanie 4 bajtów do Format
		Strumien->Read(riff.Format, 0, 4);
		//jeśli Format nierówne "WAVE" to wyrzucenie wyjątku
			if(String::Compare(this->DoString(riff.Format), "WAVE") != 0)
				throw gcnew Exception("Niepoprawne pole Format");
		//wczytanie 4 bajtów do FmtChunkID
			Strumien->Read(this->FmtChunkID, 0, 4);
		//jeśli FmtChunkID nierówne "Fmt " to wyrzucenie wyjątku
			if(String::Compare(this->DoString(this->FmtChunkID), "fmt ") != 0)
				throw gcnew Exception("Niepoprawne pole FmtChunkID");
		//wczytanie 4 bajtów do FmtChunkSize
			this->FmtChunkSize = Strumien->ReadInt32();
		//wczytanie 2 bajtów do FmtAudioFormat
			this->FmtAudioFormat = Strumien->ReadInt16();
		//wczytanie 2 bajtów do FmtNumChannels
			this->FmtNumChannels = Strumien->ReadInt16();
		//wczytanie 4 bajtów do FmtSampleRate
			this->FmtSampleRate = Strumien->ReadInt32();
		//wczytanie 4 bajtów do FmtByteRate
			this->FmtByteRate = Strumien->ReadInt32();
		//wczytywanie 2 bajtów do FmtBlockAlign
			this->FmtBlockAlign = Strumien->ReadInt16();
		//wczytywanie 2 bajtów do FmtBitsPerSample
			this->FmtBitsPerSample = Strumien->ReadInt16();
		//gdy blok Fmt ma długość inną niż 16 bajtów
			if(this->FmtChunkSize - 16)
			{
				array<Byte> ^BlokOpcjonalny = gcnew array<Byte>(this->FmtChunkSize - 16);
				Strumien->Read(BlokOpcjonalny, 0, this->FmtChunkSize - 16);
				delete BlokOpcjonalny;
			}
			unsigned int OptionalBlockChunkSize;
		//wyrzucanie opcjonalnych bloków przed Data
			while (Strumien->Read(this->DataChunkID, 0, 4) && (String::Compare(this->DoString(this->DataChunkID), "data") != 0))
			{
				OptionalBlockChunkSize = Strumien->ReadInt32();
				array<Byte> ^BlokOpcjonalny = gcnew array<Byte>(OptionalBlockChunkSize);
				Strumien->Read(BlokOpcjonalny, 0, OptionalBlockChunkSize);
				delete BlokOpcjonalny;
			}
		//jeśli DataChunkID nierówne "data" to wyrzucenie wyjątku
			if(String::Compare(this->DoString(this->DataChunkID), "data") != 0)
				throw gcnew Exception("Niepoprawne pole DataChunkID");
		//wczytanie 4 bajtów do DataChunkSize
			this->DataChunkSize = Strumien->ReadInt32();
			this->Data = gcnew array<Int16>(static_cast<Int32>(this->DataChunkSize * 0.5));
		//wypełnienie Data
			for(int i = 0; i < this->Data->Length; i++)
			{
				this->Data[i] = Strumien->ReadInt16();
			}
	}
	//wyjątek zamkniecia strumienia
	catch(EndOfStreamException^ E)
	{
		MessageBox::Show(E->GetType()->Name, "Error");
	}
	//domyslny wyjątek
	catch(Exception^ E)
	{
		MessageBox::Show(E->Message, "Błąd");	
	}
	finally
	{
	//zamknięcie strumienia
		Strumien->Close();
	}
}