Нет звука в выходном .wav файле при записи

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
using namespace std;
 
struct WavHeader
{
    char                chunkId[4];     // RIFF, FMT, DATA, e.t.c.
    unsigned long       ChunkSize;      // Chunk Size  
};
 
struct RiffHeader : WavHeader
{
    char                format[4];      // WAVE Header      
};
 
struct FmtHeader : WavHeader
{                            
    unsigned short      AudioFormat;    // Audio format 1=PCM,6=mulaw,7=alaw, 257=IBM Mu-Law, 258=IBM A-Law, 259=ADPCM 
    unsigned short      NumOfChan;      // Number of channels 1=Mono 2=Sterio                   
    unsigned long       SamplesPerSec;  // Sampling Frequency in Hz                             
    unsigned long       bytesPerSec;    // bytes per second 
    unsigned short      blockAlign;     // 2=16-bit mono, 4=16-bit stereo 
    unsigned short      bitsPerSample;  // Number of bits per sample
};
 
struct DataHeader : WavHeader
{
};
 
struct Wav
{
    RiffHeader RiffHeader;
    FmtHeader FmtHeader;
    DataHeader DataHeader;
    vector<char> Data;
};
 
/// <summary>
/// Read/write .wav files.
/// </summary>
class WavFileManager
{
public:
    /// <summary>
    /// Read whole .wav file.
    /// </summary>
    /// <param name="path">Path to file.</param>
    Wav ReadAll(const string& path)
    {
        ifstream file(path);
 
        if (!file)
        {
            throw runtime_error("Can't open file: " + path);
        }
 
        Wav* wavFile = new Wav();
 
        wavFile->RiffHeader = ReadHeader<RiffHeader>(file);
 
        if (wavFile->RiffHeader.format != "WAVE\0")
        {
            // throw runtime_error("Wrong format. File: " + path);
        }
 
        wavFile->FmtHeader = ReadHeader<FmtHeader>(file);
 
        if (!TrySkipChunksBefore(file, "data"))
        {
            throw runtime_error("Can't find wav data. File: " + path);
        }
 
        wavFile->DataHeader = ReadHeader<DataHeader>(file);
 
 
        vector<char>& data = wavFile->Data;
        data.reserve(wavFile->DataHeader.ChunkSize);
        for (int i = 0; i < wavFile->DataHeader.ChunkSize; i++)
        {
            char buffer;
            file.read((char*)&buffer, sizeof(char));
            data.push_back(buffer);
        }
        reverse(data.begin(), data.end());
 
 
        file.close();
        return *wavFile;
    }
 
    /// <summary>
    /// Read header of .wav file.
    /// </summary>
    /// <param name="file">File stream.</param>
    /// <returns>Header of type T.</returns>
    template<typename T>
    T ReadHeader(ifstream& file)
    {
        T header;
        int headerSize = sizeof(T);
        file.read((char*)&header, headerSize);
        return header;
    }
 
    /// <summary>
    /// Read data chunk of .wav file.
    /// </summary>
    /// <param name="file">File stream.</param>
    /// <param name="size">Chunk size.</param>
    /// <returns>Array of bytes.</returns>
    char* ReadChunk(ifstream& file, unsigned long size)
    {
        char* chunk = new char[size];
        file.read(chunk, size);
        return chunk;
    }
 
    /// <summary>
    /// Check if .wav header has following chunkId.
    /// </summary>
    /// <param name="header">.wav header.</param>
    /// <param name="chunkId">Id to compare.</param>
    bool HasChunkID(const WavHeader& header, const char chunkId[4])
    {
        return ((header.chunkId[0] == chunkId[0]) &&
            (header.chunkId[1] == chunkId[1]) &&
            (header.chunkId[2] == chunkId[2]) &&
            (header.chunkId[3] == chunkId[3]));
    }
 
    /// <summary>
    /// Skip all chunks before reqired chunk.
    /// </summary>
    /// <param name="file">File stream.</param>
    /// <param name="chunkId">Id of required chunk.</param>
    bool TrySkipChunksBefore(ifstream& file, const char chunkId[4])
    {
        while (!file.eof())
        {
            streampos pos = file.tellg();
            WavHeader header = ReadHeader<WavHeader>(file);
            char* chunk = ReadChunk(file, header.ChunkSize);
            if (HasChunkID(header, chunkId))
            {
                file.clear();
                file.seekg(pos);
                return true;
            }
            delete[] chunk;
        }
        return false;
    }
 
    /// <summary>
    /// Write all data into file.
    /// </summary>
    /// <param name="data">Wav to write.</param>
    /// <param name="path">Path to output file.</param>
    void WriteAll(Wav data, const string& path)
    {
        ofstream file(path, ios::binary);
        file.write((char*)&data.RiffHeader, sizeof(RiffHeader));
        file.write((char*)&data.FmtHeader, sizeof(FmtHeader));
        file.write((char*)&data.DataHeader, sizeof(DataHeader));
        reverse(data.Data.begin(), data.Data.end());
        for (int i = 0; i < data.Data.size(); i++)
        {
            file.write((char*)&data.Data[i], sizeof(char));
        }
        file.close();
    }
};
 
int main()
try
{
    auto* mgr = new WavFileManager();
    auto wav = mgr->ReadAll ("input.wav");
    mgr->WriteAll(wav, "output.wav");
}
catch (runtime_error& e)
{
    cerr << "Error! " << e.what() << '\n';
}

//------------------------     
fseek(fp_in, (cur_next * byte_block) - crutch// КОРРЕКЦИЯ ======= ПРИБАВИТЬ ДВА (НЕ КОМПИЛИРУЕТ) ИЛИ ОТНЯТЬ
                , SEEK_SET);//<--- указатель положения в файле fseek ( ======= Правильно читать данные из входного файла ======= )
        //------------------------        
        _int8 buffer[8]; unsigned int nBuff = 0;
        while (fread(buffer, 1, byte_block, fp_in) == byte_block && nBuff < size_next){
                        
            if (header.audioFormat == 3){// Тридцатьдва бита
                //===========================   Пытаюсь регулировать звук float... (нижний блок short) 
                float *one = (float*)buffer;
                float sample[2];
                sample[0] = *one; one++; sample[1] = *one;
                sample[0] *= audio_set;
                sample[1] *= audio_set;
                //--------------------------
                _int8 *two = (_int8*)sample;
                for (int i = 0; i < 8; i++){ buffer[i] = *two; two++; }
 
                //===========================       
            } else if (byte_block == 4){// Шестнадцать бит
                short *one = (short*)buffer;
                short sample[2];
                sample[0] = *one; one++; sample[1] = *one;
                sample[0] *= audio_set;
                sample[1] *= audio_set;
                //--------------------------
                _int8 *two = (_int8*)sample;
                for (int i = 0; i < 4; i++){ buffer[i] = *two; two++; }
            }
  
 fwrite(buffer, 1, byte_block, fp_out);//<======== гоним данные в файл пока не конец файла, или кончиться фрагмент
            ++nBuff;
           }
      counter += nBuff;// Сбор общего размера... Т.Е. реально записанных восьмибайтных семплов (или четырёхбайтных при моно)
        ++indx;
        }
      else {
          Sleep(5);
            // Beep(3000,10);
            if (file_end) break; } //  очередь дописана(Сброс работы потока...из основной программы)
           }
//==========================================================================================    
    } else {
        
        header.chunkSize = WAVHEADER_SIZE - 8 +
            sizeof(WAV_FACT_CHUNK)+sizeof(WAV_DATA_CHUNK)+counter * byte_block;
      
header.subchunk2Size = counter * byte_block;// <<<======== header.blockAlign (с этой  уйни размер читаеться) это я изменил по новому
                        
        //-------------------- Запись шапки ----- Иб чие структуры не пишу -----------------------------------
        fseek(fp_out, 0, SEEK_SET);// SEEK_SET ---указатель положения в файле в начало файла
        size_t res = fwrite(&header, WAVHEADER_SIZE, 1, fp_out); //<------------писать WAVHEADER
        if (res<1)printf("data fwrite error!\n");
        fclose(fp_out); fclose(fp_in);
        std::cout << " --- close treadAudio--- " << std::endl;
    }
    return 0;
}

ifstream file(path);

ifstream file(path, ios::binary);

//формирование заголовков WAV-файла
    WAVHEADER header={
        {'R','I','F','F'},0,
        {'W','A','V','E'},{'f','m','t',' '},18,0,0,0,0,0,0,0
    };
 
header.chunkSize = WAVHEADER_SIZE - 8 +
         sizeof(WAV_FACT_CHUNK) +sizeof(WAV_DATA_CHUNK) + counter * pwfx->nBlockAlign;
                    header.audioFormat = wFormatTag;// Вообще то тройка здесь
    header.numChannels = pwfx->nChannels;
    header.sampleRate = pwfx->nSamplesPerSec;
    header.byteRate = pwfx->nAvgBytesPerSec;
    header.blockAlign = pwfx->nBlockAlign;
    header.bitsPerSample = pwfx->wBitsPerSample;
    fact.dwSampleLength = counter * pwfx->nChannels;
             data.subchunk2Size = counter * pwfx->nBlockAlign;// <------ получаеться размер в байтах
  //------------------------------------------------------------
       fseek(fp, 0, SEEK_SET);// SEEK_SET ---указатель положения в файле в начало файла
          res = fwrite(&header,WAVHEADER_SIZE,1,fp); //<------------писать WAVHEADER
    if(res<1)printf("header fwrite error!\n");
        res = fwrite(&fact,sizeof(fact),1,fp);
    if(res<1)printf("fact fwrite error!\n");
        res = fwrite(&data,sizeof(data),1,fp);
    if(res<1)printf("data fwrite error!\n");
//====================================================== END запись заголовка файла