void testChannelMatrixReading(int sampleFormat, int sampleWidth)
{
// Create test file.
const int channelCount = 2;
const int frameCount = 10;
const T samples[channelCount * frameCount] =
{
2, 3, 5, 7, 11,
13, 17, 19, 23, 29,
31, 37, 41, 43, 47,
53, 59, 61, 67, 71
};
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_AIFFC);
afInitChannels(setup, AF_DEFAULT_TRACK, 2);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, sampleFormat, sampleWidth);
AFfilehandle file = afOpenFile(kTestFileName, "w", setup);
afFreeFileSetup(setup);
EXPECT_TRUE(file);
AFframecount framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK,
samples, frameCount);
EXPECT_EQ(framesWritten, frameCount);
EXPECT_EQ(afCloseFile(file), 0);
// Open file for reading and read data using different channel matrices.
file = afOpenFile(kTestFileName, "r", NULL);
EXPECT_TRUE(file);
EXPECT_EQ(afGetChannels(file, AF_DEFAULT_TRACK), 2);
EXPECT_EQ(afGetFrameCount(file, AF_DEFAULT_TRACK), frameCount);
afSetVirtualChannels(file, AF_DEFAULT_TRACK, 1);
for (int c=0; c<2; c++)
{
double channelMatrix[2] = { 0, 0 };
channelMatrix[c] = 1;
afSetChannelMatrix(file, AF_DEFAULT_TRACK, channelMatrix);
EXPECT_EQ(afSeekFrame(file, AF_DEFAULT_TRACK, 0), 0);
T *readSamples = new T[frameCount];
AFframecount framesRead = afReadFrames(file, AF_DEFAULT_TRACK,
readSamples, frameCount);
EXPECT_EQ(framesRead, frameCount);
for (int i=0; i<frameCount; i++)
EXPECT_EQ(readSamples[i], samples[2*i + c]);
delete [] readSamples;
}
EXPECT_EQ(afCloseFile(file), 0);
::unlink(kTestFileName);
}
void testfloat (int fileFormat)
{
AFfilesetup setup;
AFfilehandle file;
int framesWritten, framesRead;
const int frameCount = SAMPLE_COUNT/2;
float readsamples[SAMPLE_COUNT];
int i;
int sampleFormat, sampleWidth;
setup = afNewFileSetup();
afInitFileFormat(setup, fileFormat);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_FLOAT, 32);
afInitChannels(setup, AF_DEFAULT_TRACK, 2);
ensure(createTemporaryFile("testfloat", &sTestFileName),
"could not create temporary file");
file = afOpenFile(sTestFileName, "w", setup);
ensure(file != AF_NULL_FILEHANDLE, "could not open file for writing");
afFreeFileSetup(setup);
framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, samples,
frameCount);
ensure(framesWritten == frameCount, "number of frames written does not match number of frames requested");
ensure(afCloseFile(file) == 0, "error closing file");
file = afOpenFile(sTestFileName, "r", AF_NULL_FILESETUP);
ensure(file != AF_NULL_FILEHANDLE, "could not open file for reading");
ensure(afGetChannels(file, AF_DEFAULT_TRACK) == 2,
"file doesn't have exactly two channels");
afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
ensure(sampleFormat == AF_SAMPFMT_FLOAT && sampleWidth == 32,
"file doesn't contain 32-bit floating-point data");
ensure(afGetFileFormat(file, NULL) == fileFormat,
"file format doesn't match format requested");
framesRead = afReadFrames(file, AF_DEFAULT_TRACK, readsamples,
frameCount);
ensure(framesRead == frameCount, "number of frames read does not match number of frames requested");
for (i=0; i<SAMPLE_COUNT; i++)
{
ensure(readsamples[i] == samples[i],
"data written to file doesn't match data read");
}
ensure(afCloseFile(file) == 0, "error closing file");
cleanup();
}
TEST(NeXT, UnspecifiedLength)
{
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("NeXT", &testFileName));
int fd = ::open(testFileName.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644);
ASSERT_GT(fd, -1);
ASSERT_EQ(::write(fd, kDataUnspecifiedLength, sizeof (kDataUnspecifiedLength)), sizeof (kDataUnspecifiedLength));
::close(fd);
AFfilehandle file = afOpenFile(testFileName.c_str(), "r", NULL);
EXPECT_TRUE(file);
int sampleFormat, sampleWidth;
afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
EXPECT_TRUE(sampleFormat == AF_SAMPFMT_TWOSCOMP);
EXPECT_EQ(sampleWidth, 16);
EXPECT_EQ(afGetChannels(file, AF_DEFAULT_TRACK), 1);
EXPECT_EQ(afGetTrackBytes(file, AF_DEFAULT_TRACK),
kFrameCount * sizeof (int16_t));
EXPECT_EQ(afGetFrameCount(file, AF_DEFAULT_TRACK), kFrameCount);
int16_t *data = new int16_t[kFrameCount];
AFframecount framesRead = afReadFrames(file, AF_DEFAULT_TRACK, data,
kFrameCount);
EXPECT_EQ(framesRead, kFrameCount);
for (int i=0; i<kFrameCount; i++)
EXPECT_EQ(data[i], kFrames[i]);
delete [] data;
afCloseFile(file);
ASSERT_EQ(::unlink(testFileName.c_str()), 0);
}
static void signal_load(signal_source_t *sig, const char *name)
{
float x;
sig->name = name;
if ((sig->handle = afOpenFile(sig->name, "r", 0)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", sig->name);
exit(2);
}
if ((x = afGetFrameSize(sig->handle, AF_DEFAULT_TRACK, 1)) != 2.0)
{
fprintf(stderr, " Unexpected frame size in wave file '%s'\n", sig->name);
exit(2);
}
if ((x = afGetRate(sig->handle, AF_DEFAULT_TRACK)) != (float) SAMPLE_RATE)
{
printf(" Unexpected sample rate in wave file '%s'\n", sig->name);
exit(2);
}
if ((x = afGetChannels(sig->handle, AF_DEFAULT_TRACK)) != 1.0)
{
printf(" Unexpected number of channels in wave file '%s'\n", sig->name);
exit(2);
}
sig->max = afReadFrames(sig->handle, AF_DEFAULT_TRACK, sig->signal, SAMPLE_RATE);
if (sig->max < 0)
{
fprintf(stderr, " Error reading sound file '%s'\n", sig->name);
exit(2);
}
}
void writeMiscellaneous(int fileFormat, const std::string &testFileName)
{
AFfilesetup setup = afNewFileSetup();
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
afInitFileFormat(setup, fileFormat);
int *miscIDs = new int[kNumMiscellaneous];
for (int i=0; i<kNumMiscellaneous; i++)
miscIDs[i] = kMiscellaneous[i].id;
afInitMiscIDs(setup, miscIDs, kNumMiscellaneous);
delete [] miscIDs;
for (int i=0; i<kNumMiscellaneous; i++)
{
afInitMiscType(setup, kMiscellaneous[i].id, kMiscellaneous[i].type);
afInitMiscSize(setup, kMiscellaneous[i].id, strlen(kMiscellaneous[i].data));
}
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_TRUE(file);
afFreeFileSetup(setup);
for (int i=0; i<kNumMiscellaneous; i++)
{
int result = afWriteMisc(file, kMiscellaneous[i].id,
kMiscellaneous[i].data,
strlen(kMiscellaneous[i].data));
EXPECT_EQ(strlen(kMiscellaneous[i].data), result);
}
const int16_t samples[] = { 1, 2, 3, 4 };
const int sampleCount = sizeof (samples) / sizeof (samples[0]);
EXPECT_EQ(sampleCount, afWriteFrames(file, AF_DEFAULT_TRACK, samples, sampleCount));
ASSERT_EQ(0, afCloseFile(file));
}
void readMiscellaneous(const std::string &testFileName)
{
AFfilehandle file = afOpenFile(testFileName.c_str(), "r", NULL);
ASSERT_TRUE(file);
int count = afGetMiscIDs(file, NULL);
EXPECT_EQ(count, kNumMiscellaneous);
int miscIDs[kNumMiscellaneous];
afGetMiscIDs(file, miscIDs);
for (int i=0; i<kNumMiscellaneous; i++)
EXPECT_EQ(miscIDs[i], kMiscellaneous[i].id);
for (int i=0; i<kNumMiscellaneous; i++)
{
int misctype = afGetMiscType(file, miscIDs[i]);
EXPECT_EQ(misctype, kMiscellaneous[i].type);
int datasize = afGetMiscSize(file, miscIDs[i]);
EXPECT_EQ(datasize, strlen(kMiscellaneous[i].data));
char *data = new char[datasize];
EXPECT_EQ(datasize, afReadMisc(file, miscIDs[i], data, datasize));
EXPECT_TRUE(!memcmp(data, kMiscellaneous[i].data, datasize));
delete [] data;
}
ASSERT_EQ(0, afCloseFile(file));
}
int main (int argc, char **argv)
{
AFfilehandle file;
AFfilesetup setup;
AUpvlist list;
if (argc != 2)
{
fprintf(stderr, "usage: instparamwrite filename\n");
}
setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_AIFFC);
file = afOpenFile(argv[1], "w", setup);
if (file == AF_NULL_FILEHANDLE)
{
fprintf(stderr, "could not open file %s for writing", argv[1]);
}
afFreeFileSetup(setup);
/* Set the base note to a 'D.' */
afSetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_BASENOTE, 50);
/* Detune down by 30 cents. */
afSetInstParamLong(file, AF_DEFAULT_INST, AF_INST_NUMCENTS_DETUNE, -30);
afCloseFile(file);
return 0;
}
void testMiscellaneousUnsupported(int fileFormat)
{
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("Miscellaneous", &testFileName));
AFfilesetup setup = afNewFileSetup();
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
afInitFileFormat(setup, fileFormat);
int *miscIDs = new int[kNumMiscellaneous];
for (int i=0; i<kNumMiscellaneous; i++)
miscIDs[i] = kMiscellaneous[i].id;
afInitMiscIDs(setup, miscIDs, kNumMiscellaneous);
delete [] miscIDs;
for (int i=0; i<kNumMiscellaneous; i++)
{
afInitMiscType(setup, kMiscellaneous[i].id, kMiscellaneous[i].type);
afInitMiscSize(setup, kMiscellaneous[i].id, strlen(kMiscellaneous[i].data));
}
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_FALSE(file);
afFreeFileSetup(setup);
ASSERT_EQ(0, ::unlink(testFileName.c_str()));
}
static boolByte _openSampleSourceAiff(void *sampleSourcePtr, const SampleSourceOpenAs openAs) {
SampleSource sampleSource = (SampleSource)sampleSourcePtr;
#if HAVE_LIBAUDIOFILE
SampleSourceAudiofileData extraData = (SampleSourceAudiofileData)(sampleSource->extraData);
#else
SampleSourcePcmData extraData = (SampleSourcePcmData)(sampleSource->extraData);
#endif
if(openAs == SAMPLE_SOURCE_OPEN_READ) {
#if HAVE_LIBAUDIOFILE
extraData->fileHandle = afOpenFile(sampleSource->sourceName->data, "r", NULL);
if(extraData->fileHandle != NULL) {
setNumChannels(afGetVirtualChannels(extraData->fileHandle, AF_DEFAULT_TRACK));
setSampleRate((float)afGetRate(extraData->fileHandle, AF_DEFAULT_TRACK));
}
#else
logInternalError("Executable was not built with a library to read AIFF files");
#endif
}
else if(openAs == SAMPLE_SOURCE_OPEN_WRITE) {
#if HAVE_LIBAUDIOFILE
AFfilesetup outfileSetup = afNewFileSetup();
afInitFileFormat(outfileSetup, AF_FILE_AIFF);
afInitByteOrder(outfileSetup, AF_DEFAULT_TRACK, AF_BYTEORDER_BIGENDIAN);
afInitChannels(outfileSetup, AF_DEFAULT_TRACK, getNumChannels());
afInitRate(outfileSetup, AF_DEFAULT_TRACK, getSampleRate());
afInitSampleFormat(outfileSetup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, DEFAULT_BITRATE);
extraData->fileHandle = afOpenFile(sampleSource->sourceName->data, "w", outfileSetup);
#else
logInternalError("Executable was not built with a library to write AIFF files");
#endif
}
else {
logInternalError("Invalid type for openAs in AIFF file");
return false;
}
if(extraData->fileHandle == NULL) {
logError("AIFF file '%s' could not be opened for '%s'",
sampleSource->sourceName->data, openAs == SAMPLE_SOURCE_OPEN_READ ? "reading" : "writing");
return false;
}
sampleSource->openedAs = openAs;
return true;
}
int main (int argc, char **argv)
{
int filefmt;
AFfilehandle file;
AFfilesetup setup;
int miscids[] = {1, 2};
int result;
if (argc < 3)
{
fprintf(stderr, "usage: %s <file format> <audio file>\n",
argv[0]);
exit(EXIT_FAILURE);
}
if (strcmp(argv[1], "aiff") == 0)
filefmt = AF_FILE_AIFF;
else if (strcmp(argv[1], "aifc") == 0)
filefmt = AF_FILE_AIFFC;
else if (strcmp(argv[1], "wave") == 0)
filefmt = AF_FILE_WAVE;
else
{
fprintf(stderr, "unrecognized file format '%s'\n", argv[1]);
exit(EXIT_FAILURE);
}
setup = afNewFileSetup();
afInitFileFormat(setup, filefmt);
afInitMiscIDs(setup, miscids, 2);
afInitMiscType(setup, 1, AF_MISC_COPY);
afInitMiscType(setup, 2, AF_MISC_NAME);
afInitMiscSize(setup, 1, strlen(copyright));
afInitMiscSize(setup, 2, strlen(name));
file = afOpenFile(argv[2], "w", setup);
if (file == NULL)
{
fprintf(stderr, "could not open file '%s' for writing\n", argv[2]);
exit(EXIT_FAILURE);
}
result = afWriteMisc(file, 1, copyright, strlen(copyright));
DEBG("wrote miscellaneous data of type %d with length = %d\n",
afGetMiscType(file, 1), result);
result = afWriteMisc(file, 2, name, strlen(name));
DEBG("wrote miscellaneous data of type %d with length = %d\n",
afGetMiscType(file, 2), result);
/* Write out two token frames of sample data. */
afWriteFrames(file, AF_DEFAULT_TRACK, data, 2);
afCloseFile(file);
afFreeFileSetup(setup);
return 0;
}
static void testInstrumentParameters(int fileFormat)
{
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("Instrument", &testFileName));
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, fileFormat);
int instrumentIDs[] = {AF_DEFAULT_INST};
int numInstruments = sizeof (instrumentIDs) / sizeof (int);
afInitInstIDs(setup, instrumentIDs, numInstruments);
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_TRUE(file);
afFreeFileSetup(setup);
afSetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_BASENOTE, 50);
afSetInstParamLong(file, AF_DEFAULT_INST, AF_INST_NUMCENTS_DETUNE, -30);
afSetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_LOVELOCITY, 22);
afSetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_HIVELOCITY, 111);
ASSERT_EQ(0, afCloseFile(file));
file = afOpenFile(testFileName.c_str(), "r", NULL);
ASSERT_TRUE(file);
ASSERT_EQ(fileFormat, afGetFileFormat(file, NULL));
ASSERT_EQ(1, afGetInstIDs(file, NULL));
int readInstrumentIDs[1] = {0};
ASSERT_EQ(1, afGetInstIDs(file, readInstrumentIDs));
ASSERT_EQ(AF_DEFAULT_INST, readInstrumentIDs[0]);
EXPECT_EQ(50,
afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_BASENOTE));
EXPECT_EQ(-30,
afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_NUMCENTS_DETUNE));
EXPECT_EQ(22,
afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_LOVELOCITY));
EXPECT_EQ(111,
afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_HIVELOCITY));
ASSERT_EQ(0, afCloseFile(file));
ASSERT_EQ(0, ::unlink(testFileName.c_str()));
}
AFfilehandle createTestFile(int sampleWidth)
{
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_AIFFC);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, sampleWidth);
AFfilehandle file = afOpenFile(m_testFileName.c_str(), "w", setup);
afFreeFileSetup(setup);
return file;
}
static AFfilehandle createTestFile(int sampleFormat, int sampleWidth)
{
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_AIFFC);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, sampleFormat, sampleWidth);
AFfilehandle file = afOpenFile(kTestFileName, "w", setup);
afFreeFileSetup(setup);
return file;
}
int main (int argc, char **argv)
{
AFfilehandle file;
long result;
int count, instids;
if (argc != 2)
{
fprintf(stderr, "usage: %s filename\n", argv[0]);
exit(EXIT_FAILURE);
}
file = afOpenFile(argv[1], "r", NULL);
if (file == AF_NULL_FILEHANDLE)
{
fprintf(stderr, "could not open file '%s'\n", argv[1]);
exit(EXIT_FAILURE);
}
count = afGetInstIDs(file, &instids);
printf("%ld instruments in file '%s'\n", count, argv[1]);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_BASENOTE);
printf("MIDI base note: %ld\n", result);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_NUMCENTS_DETUNE);
printf("detune in cents: %ld\n", result);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_LONOTE);
printf("MIDI low note: %ld\n", result);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_HINOTE);
printf("MIDI high note: %ld\n", result);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_LOVELOCITY);
printf("MIDI low velocity: %ld\n", result);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_MIDI_HIVELOCITY);
printf("MIDI high velocity: %ld\n", result);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_NUMDBS_GAIN);
printf("gain in decibels: %ld\n", result);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_SUSLOOPID);
printf("sustain loop id: %ld\n", result);
result = afGetInstParamLong(file, AF_DEFAULT_INST, AF_INST_RELLOOPID);
printf("release loop id: %ld\n", result);
afCloseFile(file);
return 0;
}
PRIVATE void access_output_file(GtkWidget *widget, GtkWidget *fs) {
Generator *g = gtk_object_get_data(GTK_OBJECT(fs), "Generator");
Data *data = g->data;
const char *filename = gtk_file_selection_get_filename(GTK_FILE_SELECTION(fs));
FILE *f;
f = fopen(filename, "rb");
if (f != NULL) {
fclose(f);
if (popup_msgbox("Confirm Overwrite", MSGBOX_YES | MSGBOX_NO, 0, MSGBOX_NO,
"The file named %s exists.\nDo you want to overwrite it?",
filename) != MSGBOX_YES) {
return;
}
}
if (data->filename != NULL)
free(data->filename);
data->filename = safe_string_dup(filename);
#ifdef NATIVE_WIN32
/* Note that libaudiofile needs a small patch to get this to work right
on Win32. Details in README.w32. */
data->output = afOpenFile(filename, "wb", data->setup);
#else
data->output = afOpenFile(filename, "w", data->setup);
#endif
data->frames_recorded = 0;
if (data->output == NULL) {
popup_msgbox("Could Not Create File", MSGBOX_OK, 0, MSGBOX_OK,
"Could not create output file %s.\n"
"Recording cancelled.",
filename);
return;
}
gtk_widget_destroy(fs); /* %%% should this be gtk_widget_hide? uber-paranoia */
}
static int audiofile_get_duration(const char *file)
{
int total_time;
AFfilehandle af_fp = afOpenFile(file, "r", NULL);
if (af_fp == AF_NULL_FILEHANDLE) {
return -1;
}
total_time = (int)
((double)afGetFrameCount(af_fp, AF_DEFAULT_TRACK)
/ afGetRate(af_fp, AF_DEFAULT_TRACK));
afCloseFile(af_fp);
return total_time;
}
SoundSample::SoundSample(std::string name, int rev)
{
uMin = rev;
samples = NULL;
#ifdef HAVE_AUDIOFILE
lowPitchOffset = highPitchOffset = 1.0;
lowVolumeOffset = highVolumeOffset = 1.0;
lastDir = 0;
lastValue = 0;
file = afOpenFile(name.c_str(), "r", 0);
if (file == AF_NULL_FILEHANDLE)
{
QMessageBox::critical(theWindow, "Error",
"SoundSample::afOpenFD() - failed!",
QMessageBox::Ok,
QMessageBox::Ok);
}
else
{
afSetVirtualSampleFormat(file, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
//afSetVirtualSampleFormat(file, AF_DEFAULT_TRACK, AF_SAMPFMT_FLOAT, 32);
channels = afGetChannels(file, AF_DEFAULT_TRACK);
samplesPerSec = (int)afGetRate(file, AF_DEFAULT_TRACK);
numSamples = afGetFrameCount(file, AF_DEFAULT_TRACK);
sampleBlocksize = (int)afGetVirtualFrameSize(file, AF_DEFAULT_TRACK, 1);
bytesPerSample = (int)afGetVirtualFrameSize(file, AF_DEFAULT_TRACK, 1) / channels;
if (channels != 2)
{
std::strstream buf;
buf << "SoundSample::not a stereo sound file" << name;
std::string s;
buf >> s;
QMessageBox::critical(theWindow, "Error",
s.c_str(),
QMessageBox::Ok,
QMessageBox::Ok);
}
if (samplesPerSec != 48000)
{
std::strstream buf;
buf << "SoundSample::48kHz required but " << name << " has " << samplesPerSec;
std::string s;
buf >> s;
QMessageBox::critical(theWindow, "Error",
s.c_str(),
QMessageBox::Ok,
QMessageBox::Ok);
}
void runTest(int fileFormat, int sampleFormat, int sampleWidth)
{
IgnoreErrors ignoreErrors;
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("InvalidSampleFormat", &testFileName));
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, fileFormat);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, sampleFormat, sampleWidth);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
ASSERT_TRUE(afOpenFile(testFileName.c_str(), "w", setup) == AF_NULL_FILEHANDLE);
afFreeFileSetup(setup);
ASSERT_EQ(::unlink(testFileName.c_str()), 0);
}
static void testInvalidSampleFormat(int sampleFormat, int sampleWidth)
{
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("ALAC", &testFileName));
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_CAF);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, sampleFormat, sampleWidth);
afInitCompression(setup, AF_DEFAULT_TRACK, AF_COMPRESSION_ALAC);
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_FALSE(file);
afFreeFileSetup(setup);
ASSERT_EQ(::unlink(testFileName.c_str()), 0);
}
int main (int argc, char **argv)
{
AFfilehandle file;
int *miscids;
int i, misccount;
if (argc < 2)
{
fprintf(stderr, "usage: %s <audio file>\n", argv[0]);
exit(EXIT_FAILURE);
}
file = afOpenFile(argv[1], "r", NULL);
if (file == NULL)
{
fprintf(stderr, "could not open file %s for reading\n", argv[1]);
exit(EXIT_FAILURE);
}
misccount = afGetMiscIDs(file, NULL);
miscids = malloc(sizeof (int) * misccount);
afGetMiscIDs(file, miscids);
for (i=0; i<misccount; i++)
{
char *data;
int datasize;
datasize = afGetMiscSize(file, miscids[i]);
printf("Miscellaneous %d, %d bytes:\n",
afGetMiscType(file, miscids[i]), datasize);
/*
We know that the data in this test is a string,
so make the buffer large enough for a null terminator.
*/
data = malloc(datasize+1);
afReadMisc(file, miscids[i], data, datasize);
data[datasize] = '\0';
puts(data);
free(data);
}
afCloseFile(file);
return 0;
}
TEST(NeXT, ZeroChannels)
{
IgnoreErrors ignoreErrors;
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("NeXT", &testFileName));
int fd = ::open(testFileName.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644);
ASSERT_GT(fd, -1);
ASSERT_EQ(::write(fd, kDataZeroChannels, sizeof (kDataZeroChannels)), sizeof (kDataZeroChannels));
::close(fd);
AFfilehandle file = afOpenFile(testFileName.c_str(), "r", NULL);
EXPECT_FALSE(file);
ASSERT_EQ(::unlink(testFileName.c_str()), 0);
}
static void testInstrumentUnsupported(int fileFormat)
{
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("Instrument", &testFileName));
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, fileFormat);
int instrumentIDs[] = {AF_DEFAULT_INST};
int numInstruments = sizeof (instrumentIDs) / sizeof (int);
afInitInstIDs(setup, instrumentIDs, numInstruments);
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_FALSE(file);
afFreeFileSetup(setup);
ASSERT_EQ(0, ::unlink(testFileName.c_str()));
}
TEST(ALAC, InvalidChannels)
{
IgnoreErrors ignoreErrors;
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("ALAC", &testFileName));
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_CAF);
afInitChannels(setup, AF_DEFAULT_TRACK, 9);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
afInitCompression(setup, AF_DEFAULT_TRACK, AF_COMPRESSION_ALAC);
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_FALSE(file);
afFreeFileSetup(setup);
ASSERT_EQ(::unlink(testFileName.c_str()), 0);
}
int
SoundSampleGetData(const char *file, SoundSampleData * ssd)
{
AFfilehandle in_file;
int in_format, in_width, bytes_per_frame, frame_count;
int frames_read;
in_file = afOpenFile(file, "r", NULL);
if (!in_file)
return -1;
frame_count = afGetFrameCount(in_file, AF_DEFAULT_TRACK);
ssd->channels = afGetChannels(in_file, AF_DEFAULT_TRACK);
ssd->rate = (unsigned int)(afGetRate(in_file, AF_DEFAULT_TRACK) + .5);
afGetSampleFormat(in_file, AF_DEFAULT_TRACK, &in_format, &in_width);
ssd->bit_per_sample = in_width;
#ifdef WORDS_BIGENDIAN
afSetVirtualByteOrder(in_file, AF_DEFAULT_TRACK, AF_BYTEORDER_BIGENDIAN);
#else
afSetVirtualByteOrder(in_file, AF_DEFAULT_TRACK, AF_BYTEORDER_LITTLEENDIAN);
#endif
if (EDebug(EDBUG_TYPE_SOUND))
Eprintf("SoundSampleGetData chan=%d width=%d rate=%d\n", ssd->channels,
ssd->bit_per_sample, ssd->rate);
bytes_per_frame = (ssd->bit_per_sample * ssd->channels) / 8;
ssd->size = frame_count * bytes_per_frame;
ssd->data = EMALLOC(unsigned char, ssd->size);
frames_read =
afReadFrames(in_file, AF_DEFAULT_TRACK, ssd->data, frame_count);
afCloseFile(in_file);
if (frames_read <= 0)
{
ssd->size = 0;
_EFREE(ssd->data);
return -1;
}
return 0;
}
int main (int argc, char **argv)
{
AUpvlist list;
int size;
AFfilehandle file;
long f**k = 99;
if (argc != 2)
{
fprintf(stderr, "usage: testaupv filename\n");
exit(EXIT_FAILURE);
}
file = afOpenFile(argv[1], "r", NULL);
list = AUpvnew(4);
size = AUpvgetmaxitems(list);
printf("AUpvsetparam: %d\n", AUpvsetparam(list, 0, AF_INST_MIDI_BASENOTE));
printf("AUpvsetparam: %d\n", AUpvsetparam(list, 1, AF_INST_MIDI_LONOTE));
printf("AUpvsetparam: %d\n", AUpvsetparam(list, 2, AF_INST_SUSLOOPID));
printf("AUpvsetparam: %d\n", AUpvsetparam(list, 3, AF_INST_RELLOOPID));
afGetInstParams(file, AF_DEFAULT_INST, list, 4);
AUpvgetval(list, 0, &f**k);
printf("AUpvgetval: %ld\n", f**k);
AUpvgetval(list, 1, &f**k);
printf("AUpvgetval: %ld\n", f**k);
AUpvgetval(list, 2, &f**k);
printf("AUpvgetval: %ld\n", f**k);
AUpvgetval(list, 3, &f**k);
printf("AUpvgetval: %ld\n", f**k);
afCloseFile(file);
return 0;
}
/*
0.73s 44100.00 aiff 1ch 16b -- flute.aif
*/
bool printshortinfo (const char *filename)
{
AFfilehandle file = afOpenFile(filename, "r", NULL);;
if (!file)
return false;
int fileFormat = afGetFileFormat(file, NULL);
double sampleRate = afGetRate(file, AF_DEFAULT_TRACK);
double duration = afGetFrameCount(file, AF_DEFAULT_TRACK) / sampleRate;
const char *labelString =
(const char *) afQueryPointer(AF_QUERYTYPE_FILEFMT, AF_QUERY_LABEL,
fileFormat, 0, 0);
int channels = afGetChannels(file, AF_DEFAULT_TRACK);
int sampleFormat, sampleWidth;
afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
int compressionType = afGetCompression(file, AF_DEFAULT_TRACK);
const char *compressionName = "--";
if (compressionType != AF_COMPRESSION_NONE)
{
compressionName =
(const char *) afQueryPointer(AF_QUERYTYPE_COMPRESSION,
AF_QUERY_NAME, compressionType, 0, 0);
if (!compressionName)
compressionName = "unk";
}
printf("%8.2fs %8.2f %4s %2dch %2db %s %s\n",
duration,
sampleRate,
labelString,
channels,
sampleWidth,
compressionName,
filename);
afCloseFile(file);
return true;
}
static enum audiotap_status audiofile_read_init(struct audiotap **audiotap,
const char *file,
struct tapenc_params *params,
uint8_t machine,
uint8_t videotype,
uint8_t *halfwaves){
uint32_t freq;
enum audiotap_status error = AUDIOTAP_LIBRARY_ERROR;
AFfilehandle fh;
if (status.audiofile_init_status != LIBRARY_OK
|| status.tapencoder_init_status != LIBRARY_OK)
return AUDIOTAP_LIBRARY_UNAVAILABLE;
fh=afOpenFile(file,"r", NULL);
if (fh == AF_NULL_FILEHANDLE)
return AUDIOTAP_LIBRARY_ERROR;
do{
if ( (freq=(uint32_t)afGetRate(fh, AF_DEFAULT_TRACK)) == -1)
break;
if (afSetVirtualChannels(fh, AF_DEFAULT_TRACK, 1) == -1)
break;
if (afSetVirtualSampleFormat(fh, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 32) == -1)
break;
if (afGetVirtualFrameSize(fh, AF_DEFAULT_TRACK, 0) != 4)
break;
error = AUDIOTAP_OK;
}while(0);
if(error != AUDIOTAP_OK){
afCloseFile(fh);
return error;
}
*halfwaves = 1;
return audio2tap_audio_open_common(audiotap,
freq,
params,
machine,
videotype,
&audiofile_read_functions,
fh);
}
static gboolean
file_open (void *dp)
{
file_driver * const d = dp;
AFfilesetup outfilesetup;
outfilesetup = afNewFileSetup();
afInitFileFormat(outfilesetup, AF_FILE_WAVE);
afInitChannels(outfilesetup, AF_DEFAULT_TRACK, 2);
afInitSampleFormat(outfilesetup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
d->outfile = afOpenFile(d->filename, "w", outfilesetup);
afFreeFileSetup(outfilesetup);
if(!d->outfile) {
error_error(_("Can't open file for writing."));
goto out;
}
/* In case we're running setuid root... */
chown(d->filename, getuid(), getgid());
d->sndbuf_size = 16384;
d->sndbuf = malloc(d->sndbuf_size);
if(!d->sndbuf) {
error_error("Can't allocate mix buffer.");
goto out;
}
d->polltag = audio_poll_add(d->pipe[1], GDK_INPUT_WRITE, file_poll_ready_playing, d);
d->firstpoll = TRUE;
d->playtime = 0.0;
return TRUE;
out:
file_release(dp);
return FALSE;
}
int main (int argc, char **argv)
{
AFfilehandle file;
AudioUnit outputUnit;
if (argc < 2)
{
fprintf(stderr, "usage: %s filename\n", argv[0]);
exit(EXIT_FAILURE);
}
file = afOpenFile(argv[1], "r", AF_NULL_FILESETUP);
if (file == AF_NULL_FILEHANDLE)
{
fprintf(stderr, "Could not open file '%s' for reading.\n", argv[1]);
exit(EXIT_FAILURE);
}
openOutput(&outputUnit);
setupOutput(&outputUnit, file);
AudioOutputUnitStart(outputUnit);
buffer = malloc(BUFFER_FRAME_COUNT *
afGetVirtualFrameSize(file, AF_DEFAULT_TRACK, 1));
while (isPlaying)
usleep(250000);
AudioOutputUnitStop(outputUnit);
AudioUnitUninitialize(outputUnit);
CloseComponent(outputUnit);
free(buffer);
afCloseFile(file);
}
int main(int argc, char *argv[])
{
AFfilehandle inhandle;
AFfilehandle refhandle;
AFfilehandle outhandle;
AFfilesetup filesetup;
int frames;
int outframes;
float x;
double pre_energy;
double post_energy;
double ref_energy;
double diff_energy;
int16_t pre_amp[BLOCKS_PER_READ*BLOCK_LEN];
int16_t post_amp[BLOCKS_PER_READ*BLOCK_LEN];
int16_t ref_amp[BLOCKS_PER_READ*BLOCK_LEN];
int16_t log_amp[BLOCKS_PER_READ*BLOCK_LEN*3];
uint8_t lpc10_data[BLOCKS_PER_READ*7];
double xx;
lpc10_encode_state_t *lpc10_enc_state;
lpc10_decode_state_t *lpc10_dec_state;
int i;
int block_no;
int log_error;
int compress;
int decompress;
const char *in_file_name;
int compress_file;
int decompress_file;
int len;
int enc_len;
int dec_len;
compress = FALSE;
decompress = FALSE;
log_error = TRUE;
in_file_name = IN_FILE_NAME;
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "-c") == 0)
{
compress = TRUE;
continue;
}
if (strcmp(argv[i], "-d") == 0)
{
decompress = TRUE;
continue;
}
if (strcmp(argv[i], "-i") == 0)
{
in_file_name = argv[++i];
continue;
}
if (strcmp(argv[i], "-l") == 0)
{
log_error = FALSE;
continue;
}
}
compress_file = -1;
decompress_file = -1;
inhandle = AF_NULL_FILEHANDLE;
refhandle = AF_NULL_FILEHANDLE;
outhandle = AF_NULL_FILEHANDLE;
if (!decompress)
{
if ((inhandle = afOpenFile(in_file_name, "r", 0)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", in_file_name);
exit(2);
}
if ((x = afGetFrameSize(inhandle, AF_DEFAULT_TRACK, 1)) != 2.0)
{
fprintf(stderr, " Unexpected frame size in wave file '%s'\n", in_file_name);
exit(2);
}
if ((x = afGetRate(inhandle, AF_DEFAULT_TRACK)) != (float) SAMPLE_RATE)
{
fprintf(stderr, " Unexpected sample rate in wave file '%s'\n", in_file_name);
exit(2);
}
if ((x = afGetChannels(inhandle, AF_DEFAULT_TRACK)) != 1.0)
{
fprintf(stderr, " Unexpected number of channels in wave file '%s'\n", in_file_name);
exit(2);
}
if ((filesetup = afNewFileSetup()) == AF_NULL_FILESETUP)
{
fprintf(stderr, " Failed to create file setup\n");
exit(2);
}
if ((refhandle = afOpenFile(REF_FILE_NAME, "r", 0)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", REF_FILE_NAME);
exit(2);
}
if ((x = afGetFrameSize(refhandle, AF_DEFAULT_TRACK, 1)) != 2.0)
{
fprintf(stderr, " Unexpected frame size in wave file '%s'\n", REF_FILE_NAME);
exit(2);
}
if ((x = afGetRate(refhandle, AF_DEFAULT_TRACK)) != (float) SAMPLE_RATE)
{
fprintf(stderr, " Unexpected sample rate in wave file '%s'\n", REF_FILE_NAME);
exit(2);
}
if ((x = afGetChannels(refhandle, AF_DEFAULT_TRACK)) != 1.0)
{
fprintf(stderr, " Unexpected number of channels in wave file '%s'\n", REF_FILE_NAME);
exit(2);
}
}
else
{
if ((decompress_file = open(DECOMPRESS_FILE_NAME, O_RDONLY)) < 0)
{
fprintf(stderr, " Cannot open decompressed data file '%s'\n", DECOMPRESS_FILE_NAME);
exit(2);
}
}
if ((filesetup = afNewFileSetup()) == AF_NULL_FILESETUP)
{
fprintf(stderr, " Failed to create file setup\n");
exit(2);
}
afInitSampleFormat(filesetup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
afInitRate(filesetup, AF_DEFAULT_TRACK, (float) SAMPLE_RATE);
afInitFileFormat(filesetup, AF_FILE_WAVE);
afInitChannels(filesetup, AF_DEFAULT_TRACK, 1);
if ((outhandle = afOpenFile(OUT_FILE_NAME, "w", filesetup)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot create wave file '%s'\n", OUT_FILE_NAME);
exit(2);
}
if ((lpc10_enc_state = lpc10_encode_init(NULL, TRUE)) == NULL)
{
fprintf(stderr, " Cannot create encoder\n");
exit(2);
}
if ((lpc10_dec_state = lpc10_decode_init(NULL, TRUE)) == NULL)
{
fprintf(stderr, " Cannot create decoder\n");
exit(2);
}
if (compress)
{
if ((compress_file = open(COMPRESS_FILE_NAME, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0)
{
fprintf(stderr, " Cannot create compressed data file '%s'\n", COMPRESS_FILE_NAME);
exit(2);
}
}
pre_energy = 0.0;
post_energy = 0.0;
ref_energy = 0.0;
diff_energy = 0.0;
if (decompress)
{
while ((len = read(decompress_file, lpc10_data, BLOCKS_PER_READ*7)) > 0)
{
lpc10_decode(lpc10_dec_state, post_amp, lpc10_data, len/7);
outframes = afWriteFrames(outhandle, AF_DEFAULT_TRACK, post_amp, BLOCK_LEN*len/7);
}
}
else
{
block_no = 0;
while ((frames = afReadFrames(inhandle, AF_DEFAULT_TRACK, pre_amp, BLOCKS_PER_READ*BLOCK_LEN)) == BLOCKS_PER_READ*BLOCK_LEN
&&
(frames = afReadFrames(refhandle, AF_DEFAULT_TRACK, ref_amp, BLOCKS_PER_READ*BLOCK_LEN)) == BLOCKS_PER_READ*BLOCK_LEN)
{
enc_len = lpc10_encode(lpc10_enc_state, lpc10_data, pre_amp, BLOCKS_PER_READ*BLOCK_LEN);
if (compress)
write(compress_file, lpc10_data, enc_len);
dec_len = lpc10_decode(lpc10_dec_state, post_amp, lpc10_data, enc_len);
for (i = 0; i < dec_len; i++)
{
pre_energy += (double) pre_amp[i]*(double) pre_amp[i];
post_energy += (double) post_amp[i]*(double) post_amp[i];
ref_energy += (double) ref_amp[i]*(double) ref_amp[i];
/* The reference file has some odd clipping, so eliminate this from the
energy measurement. */
if (ref_amp[i] == 32767 || ref_amp[i] == -32768)
xx = 0.0;
else
xx = post_amp[i] - ref_amp[i];
diff_energy += (double) xx*(double) xx;
log_amp[i] = xx;
}
block_no++;
if (log_error)
outframes = afWriteFrames(outhandle, AF_DEFAULT_TRACK, log_amp, dec_len);
else
outframes = afWriteFrames(outhandle, AF_DEFAULT_TRACK, post_amp, dec_len);
}
if (afCloseFile(inhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", in_file_name);
exit(2);
}
if (afCloseFile(refhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", REF_FILE_NAME);
exit(2);
}
}
if (afCloseFile(outhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", OUT_FILE_NAME);
exit(2);
}
afFreeFileSetup(filesetup);
if (compress)
close(compress_file);
if (decompress)
close(decompress_file);
lpc10_encode_release(lpc10_enc_state);
lpc10_decode_release(lpc10_dec_state);
if (!decompress)
{
printf("Output energy is %f%% of input energy.\n", 100.0*post_energy/pre_energy);
printf("Difference energy is %f%% of the total.\n", 100.0*diff_energy/ref_energy);
if (fabs(1.0 - post_energy/pre_energy) > 0.05
||
fabs(diff_energy/post_energy) > 0.03)
{
printf("Tests failed.\n");
exit(2);
}
printf("Tests passed.\n");
}
return 0;
}