private void loadFile_Click(object sender, EventArgs e)
        {
            string file = audioManipulation.getFille("(*.wav)|*.wav");

            if (Path.GetExtension(file) == ".wav")
            {
                audioBeforeSteganography = audioManipulation.getWavFile(file);
                isSteganograph.Text      = audioSteganography.CheckWav(audioBeforeSteganography);
                AudioPlayOrginal         = new AudioPlay(file);
                var bitsToEncode = new BindingList <KeyValuePair <int, int> >();
                for (int i = 1; i <= audioBeforeSteganography.bitsPerSample; i++)
                {
                    bitsToEncode.Add(new KeyValuePair <int, int>(i, i));
                }
                comboBox1.Visible       = true;
                comboBox1.DataSource    = bitsToEncode;
                comboBox1.ValueMember   = "Key";
                comboBox1.DisplayMember = "Value";
                comboBox1.SelectedIndex = 0;
                label1.Visible          = true;;
                encodeLabel.Text        = string.Format("Wykożystujesz plik wave: {0}", Path.GetFileName(file));
                encodeLabel.Visible     = true;
                calculateFreeMemorySize();
            }
        }
 public string saveWav(WaveFille wave, Label label)
 {
     try
     {
         Stream stream;
         saveFileDialog1.Filter           = string.Format(" (*.wav)|*.wav");
         saveFileDialog1.FilterIndex      = 2;
         saveFileDialog1.RestoreDirectory = true;
         saveFileDialog1.FileName         = "wave.wav";
         if (saveFileDialog1.ShowDialog() == DialogResult.OK)
         {
             if ((stream = saveFileDialog1.OpenFile()) != null)
             {
                 stream.Write(wave.data, 0, wave.data.Length);
                 stream.Flush();
                 stream.Close();
                 label.Text      = "Plik został zapisany";
                 label.ForeColor = Color.Green;
                 return(saveFileDialog1.FileName);
             }
             label.Text      = "Nie zapisano pliku";
             label.ForeColor = Color.Red;
             return("none");
         }
         label.Text      = "Nie zapisano pliku";
         label.ForeColor = Color.Red;
         return("none");
     }
     catch (Exception ex)
     {
         label.Text      = "Nieudało śię zapisać pliku zprubój ponownie z inną nazwą";
         label.ForeColor = Color.Red;
         return("none");
     }
 }
        private void loadSteganographWav_Click(object sender, EventArgs e)
        {
            string file = audioManipulation.getFille("(*.wav)|*.wav");

            if (Path.GetExtension(file) == ".wav")
            {
                audioSteganohraph     = audioManipulation.getWavFile(file);
                AudioPlaySteganohraph = new AudioPlay(file);
                fille2Label.ForeColor = Color.Black;
                fille2Label.Text      = string.Format("Wykożystujesz plik wave: {0}", Path.GetFileName(file));
                fille2Label.Visible   = true;
            }
            else
            {
                AudioPlaySteganohraph = null;
                audioSteganohraph     = null;
                fille2Label.Text      = "Nie wybrałeś pliku wav";
                fille2Label.ForeColor = Color.Red;
                if (audioSteganohraphIsPalyed)
                {
                    AudioPlaySteganohraph.Pause();
                    audioSteganohraphIsPalyed = false;
                    playSteganograph.Text     = "Play";
                }
            }
        }
        public string DecryptBinaryInWave(byte[] wav, int bity, out string extension)
        {
            try
            {
                WaveFille audio = new WaveFille(wav);
                int       counter = 0, ammountToTake = 0, elementsToSkip = 0;
                string    maxsize = Convert.ToString(audio.totalSamples * bity, 2);
                uint      andBity = 0;// CalculateSumPowerOfTwo(bity);
                if (audio.bitsPerSample == 8)
                {
                    andBity = (uint)(0xFF >> (8 - bity));
                }
                if (audio.bitsPerSample == 16)
                {
                    andBity = (uint)(0xFFFF >> (16 - bity));
                }
                extension = "";
                StringBuilder binaryDataStringBiulder = new StringBuilder();
                if (bity <= audio.bitsPerSample)
                {
                    for (int i = 0; i < audio.samples.Count; i++)
                    {
                        uint samplequant = audio.samples[i] & (uint)andBity;
                        binaryDataStringBiulder.Append(Convert.ToString(samplequant, 2).PadLeft(bity, '0'));
                        if (binaryDataStringBiulder.Length >= maxsize.Length + extensionLenghtBinary)
                        {
                            extension     = convertBinaryToString(binaryDataStringBiulder.ToString().Substring(0, extensionLenghtBinary));
                            counter       = Convert.ToInt32(binaryDataStringBiulder.ToString().Substring(extensionLenghtBinary, maxsize.Length), 2) + extensionLenghtBinary + maxsize.Length;
                            ammountToTake = Convert.ToInt32(binaryDataStringBiulder.ToString().Substring(extensionLenghtBinary, maxsize.Length), 2);

                            binaryDataStringBiulder.Clear();
                            elementsToSkip = maxsize.Length + extensionLenghtBinary;
                            break;
                        }
                    }

                    for (int i = 0; i < audio.samples.Count && counter > 0; i++)
                    {
                        uint samplequant = audio.samples[i] & (uint)andBity;
                        binaryDataStringBiulder.Append(Convert.ToString(samplequant, 2).PadLeft(bity, '0'));
                        counter -= bity;
                    }
                    return(binaryDataStringBiulder.ToString().Substring(elementsToSkip).Substring(0, ammountToTake));
                }
                return(null);
            }
            catch (Exception ex)
            {
                extension = "";
                return(null);
            }
        }
        private void encode_Click(object sender, EventArgs e)
        {
            int bity;

            if (audioBeforeSteganography != null && textBytes != null && int.TryParse(comboBox1.Text, out bity) && taken <= maxsize)
            {
                audioAfterSteganography = audioSteganography.EncryptBinaryInWave(audioBeforeSteganography.data, textBytes, bity, "txt");
                string file = audioManipulation.saveWav(audioBeforeSteganography, message);
                if (Path.GetExtension(file) == ".wav")
                {
                    AudioPlaySteganography = new AudioPlay(file);
                }
            }
            else
            {
                message.Text      = "Coś jest nietak z podanymi danymi";
                message.ForeColor = Color.Red;
            }
        }
        private void loadFile_Click(object sender, EventArgs e)
        {
            string file = audioManipulation.getFille("(*.wav)|*.wav");

            if (file != "none" && Path.GetExtension(file) == ".wav")
            {
                audioStrganograph   = audioManipulation.getWavFile(file);
                isSteganograph.Text = audioSteganography.CheckWav(audioStrganograph);
                label1.Text         = string.Format("Używasz pliku wave: {0}", Path.GetFileName(file));
                var bitsToEncode = new BindingList <KeyValuePair <int, int> >();
                for (int i = 1; i <= audioStrganograph.bitsPerSample; i++)
                {
                    bitsToEncode.Add(new KeyValuePair <int, int>(i, i));
                }
                comboBox1.Visible       = true;
                comboBox1.DataSource    = bitsToEncode;
                comboBox1.ValueMember   = "Key";
                comboBox1.DisplayMember = "Value";
                comboBox1.SelectedIndex = 0;
                AudioPlay = new AudioPlay(file);
            }
        }
        public string CheckWav(WaveFille audio)
        {
            StringBuilder textBinary = new StringBuilder();

            string extension = "";
            uint   andBity   = 0;

            for (int bity = 1; bity <= audio.bitsPerSample; bity++)
            {
                //andBity = CalculateSumPowerOfTwo(bity);
                if (audio.bitsPerSample == 8)
                {
                    andBity = (uint)(0xFF >> (8 - bity));
                }
                if (audio.bitsPerSample == 16)
                {
                    andBity = (uint)(0xFFFF >> (16 - bity));
                }
                for (int j = 0; j < extensionLenghtBinary; j++)
                {
                    uint samplequant = audio.samples[j] & (uint)andBity;
                    textBinary.Append(Convert.ToString(samplequant, 2).PadLeft(bity, '0'));
                    if (textBinary.Length >= extensionLenghtBinary)
                    {
                        extension = convertBinaryToString(textBinary.ToString().Substring(0, extensionLenghtBinary));
                        if (extensionsList.Contains(extension))
                        {
                            return("Plik wav jest steganografem i zawiera plik z rozszeżeniem " + extension);
                        }
                        textBinary.Clear();
                        break;
                    }
                }
            }
            return("Plik wav nie jest steganografem");
        }
        private void encode_Click(object sender, EventArgs e)
        {
            int bity;

            if (audioBeforeSteganography == null)
            {
                encodeLabel.Text      = "Nie wybrałeś pliku wav";
                encodeLabel.ForeColor = Color.Red;
                return;
            }
            if (textBytes == null)
            {
                decodeLabel.Text      = "Nie wybrałeś pliku do zakodowania";
                decodeLabel.ForeColor = Color.Red;
                return;
            }

            if (audioBeforeSteganography != null && textBytes != null && int.TryParse(comboBox1.Text, out bity) && taken <= maxsize)
            {
                audioAfterSteganography = audioSteganography.EncryptBinaryInWave(audioBeforeSteganography.data, textBytes, bity, encodedeExtensionAnyFille);
                string file = audioManipulation.saveWav(audioBeforeSteganography, message);
                if (Path.GetExtension(file) == ".wav")
                {
                    AudioPlaySteganography = new AudioPlay(file);
                }
                playSteganograph.Visible = true;
                label5.Visible           = true;
            }
            else
            {
                message.Text             = "Coś jest nietak z podanymi danymi być może plik który chcesz zakodować jest za duży";
                message.ForeColor        = Color.Red;
                playSteganograph.Visible = false;
                label5.Visible           = false;
            }
        }
        public WaveFille EncryptBinaryInWave(byte[] wav, string textBinary, int bity, string extension)
        {
            try
            {
                WaveFille audio   = new WaveFille(wav);
                int       maxsize = (int)audio.totalSamples * bity;
                int       counter = 0;
                textBinary = createEncodingHeder(textBinary.Length, extension, maxsize, bity) + textBinary;
                int y = textBinary.Length;
                while (textBinary.Length % (bity) != 0)
                {
                    textBinary += '0';
                }
                if (textBinary.Length <= maxsize && bity <= audio.bitsPerSample)
                {
                    if (audio.bitsPerSample == 8)
                    {
                        //uint quant = CalculateSumPowerOfTwo((int)audio.bitsPerSample) - CalculateSumPowerOfTwo(bity);
                        uint quant = (uint)((0xFF << bity) & 0xFF);
                        for (int i = 0; i < audio.samples.Count; i++)
                        {
                            uint sampleValue = audio.samples[i];
                            sampleValue      = (sampleValue & (uint)quant);
                            sampleValue     |= Convert.ToByte(textBinary.Substring(counter, bity), 2);
                            audio.samples[i] = sampleValue;
                            counter         += bity;

                            if (counter >= textBinary.Length)
                            {
                                break;
                            }
                        }
                    }
                    if (audio.bitsPerSample == 16)
                    {
                        uint quant2 = CalculateSumPowerOfTwo((int)audio.bitsPerSample) - CalculateSumPowerOfTwo(bity);
                        uint quant  = (uint)((0xFFFF << bity) & 0xFFFF);
                        for (int i = 0; i < audio.samples.Count; i++)
                        {
                            uint sampleValue = audio.samples[i];
                            sampleValue      = (sampleValue & (uint)quant);
                            sampleValue     |= Convert.ToUInt16(textBinary.Substring(counter, bity), 2);
                            audio.samples[i] = sampleValue;
                            counter         += bity;

                            if (counter >= textBinary.Length)
                            {
                                break;
                            }
                        }
                    }
                    audio.Save(counter / bity);

                    return(audio);
                }
                else
                {
                    return(null);
                }
            }
            catch (Exception ex)
            {
                return(null);
            }
        }