| /*---------------------------------------------------------------------------- |
| * |
| * File: |
| * eas_wave.c |
| * |
| * Contents and purpose: |
| * This module contains .WAV file functions for the EAS synthesizer |
| * test harness. |
| * |
| * Copyright Sonic Network Inc. 2005 |
| |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| *---------------------------------------------------------------------------- |
| * Revision Control: |
| * $Revision: 658 $ |
| * $Date: 2007-04-24 13:35:49 -0700 (Tue, 24 Apr 2007) $ |
| *---------------------------------------------------------------------------- |
| */ |
| |
| /* lint complaints about most C library headers, so we use our own during lint step */ |
| #ifdef _lint |
| #include "lint_stdlib.h" |
| #else |
| #include <stdio.h> |
| #include <stdlib.h> |
| #endif |
| |
| #include "eas_wave.h" |
| |
| /* .WAV file format tags */ |
| const EAS_U32 riffTag = 0x46464952; |
| const EAS_U32 waveTag = 0x45564157; |
| const EAS_U32 fmtTag = 0x20746d66; |
| const EAS_U32 dataTag = 0x61746164; |
| |
| #ifdef _BIG_ENDIAN |
| /*---------------------------------------------------------------------------- |
| * FlipDWord() |
| *---------------------------------------------------------------------------- |
| * Purpose: Endian flip a DWORD for big-endian processors |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static void FlipDWord (EAS_U32 *pValue) |
| { |
| EAS_U8 *p; |
| EAS_U32 temp; |
| |
| p = (EAS_U8*) pValue; |
| temp = (((((p[3] << 8) | p[2]) << 8) | p[1]) << 8) | p[0]; |
| *pValue = temp; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * FlipWord() |
| *---------------------------------------------------------------------------- |
| * Purpose: Endian flip a WORD for big-endian processors |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static void FlipWord (EAS_U16 *pValue) |
| { |
| EAS_U8 *p; |
| EAS_U16 temp; |
| |
| p = (EAS_U8*) pValue; |
| temp = (p[1] << 8) | p[0]; |
| *pValue = temp; |
| } |
| |
| /*---------------------------------------------------------------------------- |
| * FlipWaveHeader() |
| *---------------------------------------------------------------------------- |
| * Purpose: Endian flip the wave header for big-endian processors |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static void FlipWaveHeader (WAVE_HEADER *p) |
| { |
| |
| FlipDWord(&p->nRiffTag); |
| FlipDWord(&p->nRiffSize); |
| FlipDWord(&p->nWaveTag); |
| FlipDWord(&p->nFmtTag); |
| FlipDWord(&p->nFmtSize); |
| FlipDWord(&p->nDataTag); |
| FlipDWord(&p->nDataSize); |
| FlipWord(&p->fc.wFormatTag); |
| FlipWord(&p->fc.nChannels); |
| FlipDWord(&p->fc.nSamplesPerSec); |
| FlipDWord(&p->fc.nAvgBytesPerSec); |
| FlipWord(&p->fc.nBlockAlign); |
| FlipWord(&p->fc.wBitsPerSample); |
| |
| } |
| #endif |
| |
| /*---------------------------------------------------------------------------- |
| * WaveFileCreate() |
| *---------------------------------------------------------------------------- |
| * Purpose: Opens a wave file for writing and writes the header |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| |
| WAVE_FILE *WaveFileCreate (const char *filename, EAS_I32 nChannels, EAS_I32 nSamplesPerSec, EAS_I32 wBitsPerSample) |
| { |
| WAVE_FILE *wFile; |
| |
| /* allocate memory */ |
| wFile = malloc(sizeof(WAVE_FILE)); |
| if (!wFile) |
| return NULL; |
| wFile->write = EAS_TRUE; |
| |
| /* create the file */ |
| wFile->file = fopen(filename,"wb"); |
| if (!wFile->file) |
| { |
| free(wFile); |
| return NULL; |
| } |
| |
| /* initialize PCM format .WAV file header */ |
| wFile->wh.nRiffTag = riffTag; |
| wFile->wh.nRiffSize = sizeof(WAVE_HEADER) - 8; |
| wFile->wh.nWaveTag = waveTag; |
| wFile->wh.nFmtTag = fmtTag; |
| wFile->wh.nFmtSize = sizeof(FMT_CHUNK); |
| |
| /* initalize 'fmt' chunk */ |
| wFile->wh.fc.wFormatTag = 1; |
| wFile->wh.fc.nChannels = (EAS_U16) nChannels; |
| wFile->wh.fc.nSamplesPerSec = (EAS_U32) nSamplesPerSec; |
| wFile->wh.fc.wBitsPerSample = (EAS_U16) wBitsPerSample; |
| wFile->wh.fc.nBlockAlign = (EAS_U16) (nChannels * (EAS_U16) (wBitsPerSample / 8)); |
| wFile->wh.fc.nAvgBytesPerSec = wFile->wh.fc.nBlockAlign * (EAS_U32) nSamplesPerSec; |
| |
| /* initialize 'data' chunk */ |
| wFile->wh.nDataTag = dataTag; |
| wFile->wh.nDataSize = 0; |
| |
| #ifdef _BIG_ENDIAN |
| FlipWaveHeader(&wFile->wh); |
| #endif |
| |
| /* write the header */ |
| if (fwrite(&wFile->wh, sizeof(WAVE_HEADER), 1, wFile->file) != 1) |
| { |
| fclose(wFile->file); |
| free(wFile); |
| return NULL; |
| } |
| |
| #ifdef _BIG_ENDIAN |
| FlipWaveHeader(&wFile->wh); |
| #endif |
| |
| /* return the file handle */ |
| return wFile; |
| } /* end WaveFileCreate */ |
| |
| /*---------------------------------------------------------------------------- |
| * WaveFileWrite() |
| *---------------------------------------------------------------------------- |
| * Purpose: Writes data to the wave file |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| EAS_I32 WaveFileWrite (WAVE_FILE *wFile, void *buffer, EAS_I32 n) |
| { |
| EAS_I32 count; |
| |
| /* make sure we have an open file */ |
| if (wFile == NULL) |
| { |
| return 0; |
| } |
| |
| #ifdef _BIG_ENDIAN |
| { |
| EAS_I32 i; |
| EAS_U16 *p; |
| p = buffer; |
| i = n >> 1; |
| while (i--) |
| FlipWord(p++); |
| } |
| #endif |
| |
| /* write the data */ |
| count = (EAS_I32) fwrite(buffer, 1, (size_t) n, wFile->file); |
| |
| /* add the number of bytes written */ |
| wFile->wh.nRiffSize += (EAS_U32) count; |
| wFile->wh.nDataSize += (EAS_U32) count; |
| |
| /* return the count of bytes written */ |
| return count; |
| } /* end WriteWaveHeader */ |
| |
| /*---------------------------------------------------------------------------- |
| * WaveFileClose() |
| *---------------------------------------------------------------------------- |
| * Purpose: Opens a wave file for writing and writes the header |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| |
| EAS_BOOL WaveFileClose (WAVE_FILE *wFile) |
| { |
| EAS_I32 count = 1; |
| |
| /* return to beginning of file and write the header */ |
| if (wFile->write) |
| { |
| if (fseek(wFile->file, 0L, SEEK_SET) == 0) |
| { |
| |
| #ifdef _BIG_ENDIAN |
| FlipWaveHeader(&wFile->wh); |
| #endif |
| count = (EAS_I32) fwrite(&wFile->wh, sizeof(WAVE_HEADER), 1, wFile->file); |
| #ifdef _BIG_ENDIAN |
| FlipWaveHeader(&wFile->wh); |
| #endif |
| } |
| } |
| |
| /* close the file */ |
| if (fclose(wFile->file) != 0) |
| count = 0; |
| |
| /* free the memory */ |
| free(wFile); |
| |
| /* return the file handle */ |
| return (count == 1 ? EAS_TRUE : EAS_FALSE); |
| } /* end WaveFileClose */ |
| |
| #ifdef _WAVE_FILE_READ |
| #ifdef _BIG_ENDIAN |
| #error "WaveFileOpen not currently supported on big-endian processors" |
| #endif |
| /*---------------------------------------------------------------------------- |
| * WaveFileOpen() |
| *---------------------------------------------------------------------------- |
| * Purpose: Opens a wave file for reading and reads the header |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| |
| WAVE_FILE *WaveFileOpen (const char *filename) |
| { |
| WAVE_FILE *wFile; |
| struct |
| { |
| EAS_U32 tag; |
| EAS_U32 size; |
| } chunk; |
| EAS_U32 tag; |
| EAS_I32 startChunkPos; |
| EAS_INT state; |
| EAS_BOOL done; |
| |
| /* allocate memory */ |
| wFile = malloc(sizeof(WAVE_FILE)); |
| if (!wFile) |
| return NULL; |
| |
| /* open the file */ |
| wFile->write = EAS_FALSE; |
| wFile->file = fopen(filename,"rb"); |
| if (!wFile->file) |
| { |
| free(wFile); |
| return NULL; |
| } |
| |
| /* make lint happy */ |
| chunk.tag = chunk.size = 0; |
| startChunkPos = 0; |
| |
| /* read the RIFF tag and file size */ |
| state = 0; |
| done = EAS_FALSE; |
| while (!done) |
| { |
| |
| switch(state) |
| { |
| /* read the RIFF tag */ |
| case 0: |
| if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1) |
| done = EAS_TRUE; |
| else |
| { |
| if (chunk.tag != riffTag) |
| done = EAS_TRUE; |
| else |
| state++; |
| } |
| break; |
| |
| /* read the WAVE tag */ |
| case 1: |
| if (fread(&tag, sizeof(tag), 1, wFile->file) != 1) |
| done = EAS_TRUE; |
| else |
| { |
| if (tag != waveTag) |
| done = EAS_TRUE; |
| else |
| state++; |
| } |
| break; |
| |
| /* looking for fmt chunk */ |
| case 2: |
| if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1) |
| done = EAS_TRUE; |
| else |
| { |
| startChunkPos = ftell(wFile->file); |
| |
| /* not fmt tag, skip it */ |
| if (chunk.tag != fmtTag) |
| fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET); |
| else |
| state++; |
| } |
| break; |
| |
| /* read fmt chunk */ |
| case 3: |
| if (fread(&wFile->wh.fc, sizeof(FMT_CHUNK), 1, wFile->file) != 1) |
| done = EAS_TRUE; |
| else |
| { |
| fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET); |
| state++; |
| } |
| break; |
| |
| /* looking for data chunk */ |
| case 4: |
| if (fread(&chunk, sizeof(chunk), 1, wFile->file) != 1) |
| done = EAS_TRUE; |
| else |
| { |
| startChunkPos = ftell(wFile->file); |
| |
| /* not data tag, skip it */ |
| if (chunk.tag != dataTag) |
| fseek(wFile->file, startChunkPos + (EAS_I32) chunk.size, SEEK_SET); |
| else |
| { |
| wFile->dataSize = chunk.size; |
| state++; |
| done = EAS_TRUE; |
| } |
| } |
| break; |
| |
| default: |
| done = EAS_TRUE; |
| break; |
| } |
| } |
| |
| /* if not final state, an error occurred */ |
| if (state != 5) |
| { |
| fclose(wFile->file); |
| free(wFile); |
| return NULL; |
| } |
| |
| /* return the file handle */ |
| return wFile; |
| } /* end WaveFileOpen */ |
| #endif |
| |
| |
| |
