/*----------------------------------------------------------------------------
*
* 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 */