| /*---------------------------------------------------------------------------- |
| * |
| * File: |
| * eas_main.c |
| * |
| * Contents and purpose: |
| * The entry point and high-level functions for the EAS Synthesizer test |
| * harness. |
| * |
| * Copyright Sonic Network Inc. 2004 |
| |
| * 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: 775 $ |
| * $Date: 2007-07-20 10:11:11 -0700 (Fri, 20 Jul 2007) $ |
| *---------------------------------------------------------------------------- |
| */ |
| |
| #ifdef _lint |
| #include "lint_stdlib.h" |
| #else |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <time.h> |
| #endif |
| |
| #include "eas.h" |
| #include "eas_wave.h" |
| #include "eas_report.h" |
| |
| /* determines how many EAS buffers to fill a host buffer */ |
| #define NUM_BUFFERS 8 |
| |
| /* default file to play if no filename is specified on the command line */ |
| static const char defaultTestFile[] = "test.mid"; |
| |
| EAS_I32 polyphony; |
| |
| /* prototypes for helper functions */ |
| static void StrCopy(char *dest, const char *src, EAS_I32 size); |
| static EAS_BOOL ChangeFileExt(char *str, const char *ext, EAS_I32 size); |
| static EAS_RESULT PlayFile (EAS_DATA_HANDLE easData, const char* filename, const char* outputFile, const S_EAS_LIB_CONFIG *pLibConfig, void *buffer, EAS_I32 bufferSize); |
| static EAS_BOOL EASLibraryCheck (const S_EAS_LIB_CONFIG *pLibConfig); |
| |
| /* main is defined after playfile to avoid the need for two passes through lint */ |
| |
| /*---------------------------------------------------------------------------- |
| * PlayFile() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * This function plays the file requested by filename |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| |
| static EAS_RESULT PlayFile (EAS_DATA_HANDLE easData, const char* filename, const char* outputFile, const S_EAS_LIB_CONFIG *pLibConfig, void *buffer, EAS_I32 bufferSize) |
| { |
| EAS_HANDLE handle; |
| EAS_RESULT result, reportResult; |
| EAS_I32 count; |
| EAS_STATE state; |
| EAS_I32 playTime; |
| char waveFilename[256]; |
| WAVE_FILE *wFile; |
| EAS_INT i; |
| EAS_PCM *p; |
| |
| /* determine the name of the output file */ |
| wFile = NULL; |
| if (outputFile == NULL) |
| { |
| StrCopy(waveFilename, filename, sizeof(waveFilename)); |
| if (!ChangeFileExt(waveFilename, "wav", sizeof(waveFilename))) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error in output filename %s\n", waveFilename); */ } |
| return EAS_FAILURE; |
| } |
| outputFile = waveFilename; |
| } |
| |
| /* call EAS library to open file */ |
| if ((reportResult = EAS_OpenFile(easData, filename, &handle)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_OpenFile returned %ld\n", reportResult); */ } |
| return reportResult; |
| } |
| |
| /* prepare to play the file */ |
| if ((result = EAS_Prepare(easData, handle)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_Prepare returned %ld\n", result); */ } |
| reportResult = result; |
| } |
| |
| /* get play length */ |
| if ((result = EAS_ParseMetaData(easData, handle, &playTime)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_ParseMetaData returned %ld\n", result); */ } |
| return result; |
| } |
| EAS_ReportEx(_EAS_SEVERITY_NOFILTER, 0xe624f4d9, 0x00000005 , playTime / 1000, playTime % 1000); |
| |
| if (reportResult == EAS_SUCCESS) |
| { |
| /* create the output file */ |
| wFile = WaveFileCreate(outputFile, pLibConfig->numChannels, pLibConfig->sampleRate, sizeof(EAS_PCM) * 8); |
| if (!wFile) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Unable to create output file %s\n", waveFilename); */ } |
| reportResult = EAS_FAILURE; |
| } |
| } |
| |
| /* rendering loop */ |
| while (reportResult == EAS_SUCCESS) |
| { |
| |
| /* we may render several buffers here to fill one host buffer */ |
| for (i = 0, p = buffer; i < NUM_BUFFERS; i++, p+= pLibConfig->mixBufferSize * pLibConfig->numChannels) |
| { |
| |
| /* get the current time */ |
| if ((result = EAS_GetLocation(easData, handle, &playTime)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_GetLocation returned %d\n",result); */ } |
| if (reportResult == EAS_SUCCESS) |
| reportResult = result; |
| break; |
| } |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_DETAIL, "Parser time: %d.%03d\n", playTime / 1000, playTime % 1000); */ } |
| |
| /* render a buffer of audio */ |
| if ((result = EAS_Render(easData, p, pLibConfig->mixBufferSize, &count)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_Render returned %d\n",result); */ } |
| if (reportResult == EAS_SUCCESS) |
| reportResult = result; |
| } |
| } |
| |
| if (result == EAS_SUCCESS) |
| { |
| /* write it to the wave file */ |
| if (WaveFileWrite(wFile, buffer, bufferSize) != bufferSize) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "WaveFileWrite failed\n"); */ } |
| reportResult = EAS_FAILURE; |
| } |
| } |
| |
| if (reportResult == EAS_SUCCESS) |
| { |
| /* check stream state */ |
| if ((result = EAS_State(easData, handle, &state)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_State returned %d\n", result); */ } |
| reportResult = result; |
| } |
| |
| /* is playback complete */ |
| if ((state == EAS_STATE_STOPPED) || (state == EAS_STATE_ERROR)) |
| break; |
| } |
| } |
| |
| /* close the output file */ |
| if (wFile) |
| { |
| if (!WaveFileClose(wFile)) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error closing wave file %s\n", waveFilename); */ } |
| if (reportResult == EAS_SUCCESS) |
| result = EAS_FAILURE; |
| } |
| } |
| |
| /* close the input file */ |
| if ((result = EAS_CloseFile(easData,handle)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "EAS_Close returned %ld\n", result); */ } |
| if (reportResult == EAS_SUCCESS) |
| result = EAS_FAILURE; |
| } |
| |
| return reportResult; |
| } /* end PlayFile */ |
| |
| /*---------------------------------------------------------------------------- |
| * main() |
| *---------------------------------------------------------------------------- |
| * Purpose: The entry point for the EAS sample application |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| int main( int argc, char **argv ) |
| { |
| EAS_DATA_HANDLE easData; |
| const S_EAS_LIB_CONFIG *pLibConfig; |
| void *buffer; |
| EAS_RESULT result, playResult; |
| EAS_I32 bufferSize; |
| int i; |
| int temp; |
| FILE *debugFile; |
| char *outputFile = NULL; |
| |
| /* set the error reporting level */ |
| EAS_SetDebugLevel(_EAS_SEVERITY_INFO); |
| debugFile = NULL; |
| |
| /* process command-line arguments */ |
| for (i = 1; i < argc; i++) |
| { |
| /* check for switch */ |
| if (argv[i][0] == '-') |
| { |
| switch (argv[i][1]) |
| { |
| case 'd': |
| temp = argv[i][2]; |
| if ((temp >= '0') || (temp <= '9')) |
| EAS_SetDebugLevel(temp); |
| else |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Invalid debug level %d\n", temp); */ } |
| break; |
| case 'f': |
| if ((debugFile = fopen(&argv[i][2],"w")) == NULL) |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_WARNING, "Unable to create debug file %s\n", &argv[i][2]); */ } |
| else |
| EAS_SetDebugFile(debugFile, EAS_TRUE); |
| break; |
| case 'o': |
| outputFile = &argv[i][2]; |
| break; |
| case 'p': |
| polyphony = atoi(&argv[i][2]); |
| if (polyphony < 1) |
| polyphony = 1; |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "Polyphony set to %d\n", polyphony); */ } |
| break; |
| default: |
| break; |
| } |
| continue; |
| } |
| } |
| |
| /* assume success */ |
| playResult = EAS_SUCCESS; |
| |
| /* get the library configuration */ |
| pLibConfig = EAS_Config(); |
| if (!EASLibraryCheck(pLibConfig)) |
| return -1; |
| if (polyphony > pLibConfig->maxVoices) |
| polyphony = pLibConfig->maxVoices; |
| |
| /* calculate buffer size */ |
| bufferSize = pLibConfig->mixBufferSize * pLibConfig->numChannels * (EAS_I32)sizeof(EAS_PCM) * NUM_BUFFERS; |
| |
| /* allocate output buffer memory */ |
| buffer = malloc((EAS_U32)bufferSize); |
| if (!buffer) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Error allocating memory for audio buffer\n"); */ } |
| return EAS_FAILURE; |
| } |
| |
| /* initialize the EAS library */ |
| polyphony = pLibConfig->maxVoices; |
| if ((result = EAS_Init(&easData)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "EAS_Init returned %ld - aborting!\n", result); */ } |
| free(buffer); |
| return result; |
| } |
| |
| /* |
| * Some debugging environments don't allow for passed parameters. |
| * In this case, just play the default MIDI file "test.mid" |
| */ |
| if (argc < 2) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "Playing '%s'\n", defaultTestFile); */ } |
| if ((playResult = PlayFile(easData, defaultTestFile, NULL, pLibConfig, buffer, bufferSize)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %d playing file %s\n", playResult, defaultTestFile); */ } |
| } |
| } |
| /* iterate through the list of files to be played */ |
| else |
| { |
| for (i = 1; i < argc; i++) |
| { |
| /* check for switch */ |
| if (argv[i][0] != '-') |
| { |
| |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "Playing '%s'\n", argv[i]); */ } |
| if ((playResult = PlayFile(easData, argv[i], outputFile, pLibConfig, buffer, bufferSize)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_ERROR, "Error %d playing file %s\n", playResult, argv[i]); */ } |
| break; |
| } |
| } |
| } |
| } |
| |
| /* shutdown the EAS library */ |
| if ((result = EAS_Shutdown(easData)) != EAS_SUCCESS) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "EAS_Shutdown returned %ld\n", result); */ } |
| } |
| |
| /* free the output buffer */ |
| free(buffer); |
| |
| /* close the debug file */ |
| if (debugFile) |
| fclose(debugFile); |
| |
| /* play errors take precedence over shutdown errors */ |
| if (playResult != EAS_SUCCESS) |
| return playResult; |
| return result; |
| } /* end main */ |
| |
| /*---------------------------------------------------------------------------- |
| * StrCopy() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Safe string copy |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static void StrCopy(char *dest, const char *src, EAS_I32 size) |
| { |
| int len; |
| |
| strncpy(dest, src, (size_t) size-1); |
| len = (int) strlen(src); |
| if (len < size) |
| dest[len] = 0; |
| } /* end StrCopy */ |
| |
| /*---------------------------------------------------------------------------- |
| * ChangeFileExt() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Changes the file extension of a filename |
| * |
| * Inputs: |
| * |
| * Outputs: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_BOOL ChangeFileExt(char *str, const char *ext, EAS_I32 size) |
| { |
| char *p; |
| |
| /* find the extension, if any */ |
| p = strrchr(str,'.'); |
| if (!p) |
| { |
| if ((EAS_I32)(strlen(str) + 5) > size) |
| return EAS_FALSE; |
| strcat(str,"."); |
| strcat(str,ext); |
| return EAS_TRUE; |
| } |
| |
| /* make sure there's room for the extension */ |
| p++; |
| *p = 0; |
| if ((EAS_I32)(strlen(str) + 4) > size) |
| return EAS_FALSE; |
| strcat(str,ext); |
| return EAS_TRUE; |
| } /* end ChangeFileExt */ |
| |
| /*---------------------------------------------------------------------------- |
| * EASLibraryCheck() |
| *---------------------------------------------------------------------------- |
| * Purpose: |
| * Displays the library version and checks it against the header |
| * file used to build this code. |
| * |
| * Inputs: |
| * pLibConfig - library configuration retrieved from the library |
| * |
| * Outputs: |
| * returns EAS_TRUE if matched |
| * |
| * Side Effects: |
| * |
| *---------------------------------------------------------------------------- |
| */ |
| static EAS_BOOL EASLibraryCheck (const S_EAS_LIB_CONFIG *pLibConfig) |
| { |
| |
| /* display the library version */ |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "EAS Library Version %d.%d.%d.%d\n", |
| pLibConfig->libVersion >> 24, |
| (pLibConfig->libVersion >> 16) & 0x0f, |
| (pLibConfig->libVersion >> 8) & 0x0f, |
| pLibConfig->libVersion & 0x0f); */ } |
| |
| /* display some info about the library build */ |
| if (pLibConfig->checkedVersion) |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tChecked library\n"); */ } |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tMaximum polyphony: %d\n", pLibConfig->maxVoices); */ } |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tNumber of channels: %d\n", pLibConfig->numChannels); */ } |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tSample rate: %d\n", pLibConfig->sampleRate); */ } |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tMix buffer size: %d\n", pLibConfig->mixBufferSize); */ } |
| if (pLibConfig->filterEnabled) |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tFilter enabled\n"); */ } |
| #ifndef _WIN32_WCE |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tLibrary Build Timestamp: %s", ctime((time_t*)&pLibConfig->buildTimeStamp)); */ } |
| #endif |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_INFO, "\tLibrary Build ID: %s\n", pLibConfig->buildGUID); */ } |
| |
| /* check it against the header file used to build this code */ |
| /*lint -e{778} constant expression used for display purposes may evaluate to zero */ |
| if (LIB_VERSION != pLibConfig->libVersion) |
| { |
| { /* dpp: EAS_ReportEx(_EAS_SEVERITY_FATAL, "Library version does not match header files. EAS Header Version %d.%d.%d.%d\n", |
| LIB_VERSION >> 24, |
| (LIB_VERSION >> 16) & 0x0f, |
| (LIB_VERSION >> 8) & 0x0f, |
| LIB_VERSION & 0x0f); */ } |
| return EAS_FALSE; |
| } |
| return EAS_TRUE; |
| } /* end EASLibraryCheck */ |
| |
