wavwrite.c

#include "wavreader.h"
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define WAV_PCM 1
#define WAV_FMTLEN 16

//#define DEBUG

struct WavHeader * readWaveHeader(FILE *fh)
{
    struct WavHeader * header;
    header = malloc(sizeof(struct WavHeader));
    fread(header, sizeof(struct WavHeader), 1, fh);
    return header;
}

struct WavHeader * createWaveHeader (uint16_t channels, uint32_t samplerate, uint16_t bits)
{
    struct WavHeader * header;
    header = malloc(sizeof(struct WavHeader));
    header->iChannels = channels;
    header->iSampleRate = samplerate;
    header->iBitsPerSample = bits;
    strncpy(header->cData, "data", 4);
    strncpy(header->cRiff, "RIFF", 4);
    strncpy(header->cFmtMarker, "fmt ", 4);
    strncpy(header->cWaveMark, "WAVE", 4);
    header->uiFileSize = 36;
    header->iFmtLen = WAV_FMTLEN;
    header->iFmtType = WAV_PCM;
    header->iDataSize = 0;
    header->iByteRate = samplerate * (bits/8) * channels;
    header->iAlignment = (bits/8) * channels;
    return header;
}

void printWaveHeader (struct WavHeader * header)
{
    char tempStr[20];
    strncpy(tempStr, header->cRiff, sizeof(header->cRiff));
    printf("RIFF = %s\n", tempStr);
    printf("Size of File = %d Bytes\n", header->uiFileSize);
    strncpy(tempStr, header->cWaveMark, sizeof(header->cWaveMark));
    printf("WAVE = %s\n", tempStr);
    strncpy(tempStr, header->cFmtMarker, sizeof(header->cFmtMarker));
    printf("FormatMark = %s\n", tempStr);
    printf("Rest Data in Format = %d Bytes\n", header->iFmtLen );
    printf("Format Type = %d \n", header->iFmtType);
    printf("Number of Channels = %d \n", header->iChannels);
    printf("Samplerate = %d Hz \n", header->iSampleRate);
    printf("Byterate = %d Bps \n", header->iByteRate);
    printf("Framesize = %d Bytes pro Frame \n", header->iAlignment);
    printf("Bits per Sample = %d bits \n", header->iBitsPerSample);
    strncpy(tempStr, header->cData, sizeof(header->cData));
    printf("DATA = %s \n", tempStr);
    printf("Data Segment Size = %d Bytes \n", header->iDataSize);
}

void _int8ToDouble(char * buffer, int buflen, double *output)
{
    int i;
    for (i = 0; i < buflen; ++i)
    {
        output[i] = 1.0 * buffer[i] / ((1 << 7) - 1); // convert to double, int8 means 2^-7 ~ (2^7-1)
    }

}

void _int16ToDouble(char * buffer, int buflen, double *output)
{
    int i;
    int16_t temp;
    int16_t iMax;

    iMax = (1 << (16-1)) - 1; // maximun for int16

    for (i = 0; i < buflen/2; ++i) // because buflen is byte number buflen/2 = length in int16
    {
        temp = (buffer[i*2+1] << 8) | (buffer[i*2]); // its little endian
        output[i] = 1.0 * temp / iMax;
#ifdef DEBUG

        printf("%02x %02x\t%04x\t%.5f\n",buffer[i*2+1],buffer[i*2], temp,output[i]);

#endif // DEBUG

    }

}

void _int32ToDouble(char *buffer, int buflen, double *output)
{
    int i;
    int32_t temp;
    int32_t iMax;

    iMax = (1 << (32 - 1)) - 1; // Max Int32

    for (i = 0; i < buflen/4; ++i) //buflen in int32 = buflen in byte / 4
    {
        temp = (buffer[i*4+3] << 24) | (buffer[i*4+2] << 16)
               | (buffer[i*4+1] << 8) | (buffer[i*4]); // little endian
        output[i] = 1.0 * temp / iMax;
    }

}

int WaveReadFrame(FILE *fh, struct WavHeader * header,int iFrameSize, double *output)
{
    char buffer[iFrameSize * header->iChannels * (header->iBitsPerSample / 8)]; // buffer of raw data
    int i,j;
    int iBytesRead;
    int64_t temp;
    int byteLen = header->iBitsPerSample / 8;


    if (!feof(fh))
    {
        iBytesRead = fread(buffer, sizeof(buffer[0]), sizeof(buffer), fh);
        switch (byteLen)
        {
            case 1:
                {
                    _int8ToDouble(buffer, iBytesRead, output);
                    break;
                }
            case 2:
                {
                    _int16ToDouble(buffer, iBytesRead, output);
                    break;
                }
            case 4:
                {
                    _int32ToDouble(buffer, iBytesRead, output);
                    break;
                }
        }
        return iBytesRead;
    }
    else
    {
        return -1;
    }
}


int _WaveWriteFrame8b(FILE *fh, struct WavHeader * header, int iFrameSize, double * frame)
{
    int i, iTotalLen;
    int8_t *iFrame;
    int8_t iMax;

    iMax = (1 << (sizeof(int8_t)*8-1)) - 1;
    iTotalLen = iFrameSize * header->iChannels;
    iFrame = malloc(sizeof(int8_t) * iFrameSize * header->iChannels);

    for (i = 0; i < iTotalLen; ++i)
    {
        iFrame[i] = (int8_t)trunc(frame[i] * iMax);
    }

    return fwrite(iFrame, sizeof(iFrame[0]), iTotalLen, fh);

}

int _WaveWriteFrame16b(FILE *fh, struct WavHeader * header, int iFrameSize, double * frame)
{
    int i, iTotalLen;
    int16_t *iFrame;
    int16_t iMax;

    iMax = (1 << (sizeof(int16_t)*8-1)) - 1;
    iTotalLen = iFrameSize * header->iChannels;
    iFrame = malloc(sizeof(int16_t) * iFrameSize * header->iChannels);

    for (i = 0; i < iTotalLen; ++i)
    {
        iFrame[i] = (frame[i] * iMax);
    }

    return fwrite(iFrame, sizeof(iFrame[0]), iTotalLen, fh);

}

int _WaveWriteFrame32b(FILE *fh, struct WavHeader * header, int iFrameSize, double * frame)
{
    int i, iTotalLen;
    int32_t *iFrame;
    int32_t iMax;

    iMax = (1 << (sizeof(int32_t)*8-1)) - 1;
    iTotalLen = iFrameSize * header->iChannels;
    iFrame = malloc(sizeof(int32_t) * iFrameSize * header->iChannels);

    for (i = 0; i < iTotalLen; ++i)
    {
        iFrame[i] = (int32_t)trunc(frame[i] * iMax);
    }

    return fwrite(iFrame, sizeof(iFrame[0]), iTotalLen, fh);

}

int WaveWriteFrame(FILE *fh, struct WavHeader * header, int iFrameSize, double *frame)
{
    int iBytesWritten;
    int iByteLen = header->iBitsPerSample / 8;
    switch (iByteLen)
    {
        case 1:
            {
                iBytesWritten = _WaveWriteFrame8b(fh, header, iFrameSize, frame);
                break;
            }
        case 2:
            {
                iBytesWritten = _WaveWriteFrame16b(fh, header, iFrameSize, frame);
                break;
            }
        case 4:
            {
                iBytesWritten = _WaveWriteFrame32b(fh, header, iFrameSize, frame);
                break;
            }
        default:
            return -1;
    }

    header->iDataSize = header->iDataSize + iBytesWritten*iByteLen;
    header->uiFileSize = header->uiFileSize + iBytesWritten*iByteLen;

    return iBytesWritten;

}

void WaveWriteHeader(FILE *fh, struct WavHeader * header)
{
    int currentPos;

    currentPos = ftell(fh);
    rewind(fh);

    fwrite(header, sizeof(struct WavHeader), 1, fh);

    fseek(fh, 0, currentPos);
}