464 lines
15 KiB
C
464 lines
15 KiB
C
/*----------------------------------------------------------------------------
|
|
*
|
|
* 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;
|
|
EAS_FILE file;
|
|
|
|
/* 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 */
|
|
file.path = filename;
|
|
file.fd = 0;
|
|
if ((reportResult = EAS_OpenFile(easData, &file, &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 */
|
|
|