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();
}
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()));
}
/*
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;
}
int main (int argc, char **argv)
{
AFfilehandle file;
AFfilesetup setup;
int8_t samples[] = {11, 51, 101, -101, -54, 120, -15, 99};
int i;
int sampleFormat, sampleWidth;
int framesRead, framesWritten;
setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_IFF_8SVX);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 8);
file = afOpenFile(TEST_FILE, "w", setup);
ensure(file != AF_NULL_FILEHANDLE, "unable to open file for writing");
framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, samples, 7);
ensure(framesWritten == 7,
"number of frames written does not match number of frames requested");
ensure(afCloseFile(file) == 0, "error closing file");
afFreeFileSetup(setup);
file = afOpenFile(TEST_FILE, "r", NULL);
ensure(file != AF_NULL_FILEHANDLE, "unable to open file for reading");
ensure(afGetFileFormat(file, NULL) == AF_FILE_IFF_8SVX,
"test file not created as IFF/8SVX");
afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
ensure(sampleFormat == AF_SAMPFMT_TWOSCOMP,
"test file not two's complement");
ensure(sampleWidth == 8,
"test file sample format is not 8-bit");
ensure(afGetChannels(file, AF_DEFAULT_TRACK) == 1,
"test file doesn't have exactly one channel");
ensure(afGetByteOrder(file, AF_DEFAULT_TRACK) == AF_BYTEORDER_BIGENDIAN,
"test file not big-endian");
for (i=0; i<7; i++)
{
int8_t temporary;
framesRead = afReadFrames(file, AF_DEFAULT_TRACK, &temporary, 1);
ensure(framesRead == 1,
"number of frames read does not match number of frames requested");
ensure(temporary == samples[i],
"data written to file doesn't match data read from file");
}
ensure(afCloseFile(file) == 0, "error closing file");
cleanup();
printf("writeiff test passed.\n");
exit(0);
}
bool printfileinfo (const char *filename)
{
AFfilehandle file = afOpenFile(filename, "r", NULL);
if (!file)
return false;
int fileFormat = afGetFileFormat(file, NULL);
const char *formatstring =
(const char *) afQueryPointer(AF_QUERYTYPE_FILEFMT, AF_QUERY_DESC,
fileFormat, 0, 0);
const char *labelstring =
(const char *) afQueryPointer(AF_QUERYTYPE_FILEFMT, AF_QUERY_LABEL,
fileFormat, 0, 0);
if (!formatstring || !labelstring)
return false;
printf("File Name %s\n", filename);
printf("File Format %s (%s)\n", formatstring, labelstring);
int sampleFormat, sampleWidth;
afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
int byteOrder = afGetByteOrder(file, AF_DEFAULT_TRACK);
printf("Data Format ");
int compressionType = afGetCompression(file, AF_DEFAULT_TRACK);
if (compressionType == AF_COMPRESSION_NONE)
{
switch (sampleFormat)
{
case AF_SAMPFMT_TWOSCOMP:
printf("%d-bit integer (2's complement, %s)",
sampleWidth,
byteOrder == AF_BYTEORDER_BIGENDIAN ?
"big endian" : "little endian");
break;
case AF_SAMPFMT_UNSIGNED:
printf("%d-bit integer (unsigned, %s)",
sampleWidth,
byteOrder == AF_BYTEORDER_BIGENDIAN ?
"big endian" : "little endian");
break;
case AF_SAMPFMT_FLOAT:
printf("single-precision (32-bit) floating point, %s",
byteOrder == AF_BYTEORDER_BIGENDIAN ?
"big endian" : "little endian");
break;
case AF_SAMPFMT_DOUBLE:
printf("double-precision (64-bit) floating point, %s",
byteOrder == AF_BYTEORDER_BIGENDIAN ?
"big endian" : "little endian");
break;
default:
printf("unknown");
break;
}
}
else
{
const char *compressionName =
(const char *) afQueryPointer(AF_QUERYTYPE_COMPRESSION,
AF_QUERY_NAME, compressionType, 0, 0);
if (!compressionName)
printf("unknown compression");
else
printf("%s compression", compressionName);
}
printf("\n");
printf("Audio Data %jd bytes begins at offset %jd (%jx hex)\n",
(intmax_t) afGetTrackBytes(file, AF_DEFAULT_TRACK),
(intmax_t) afGetDataOffset(file, AF_DEFAULT_TRACK),
(uintmax_t) afGetDataOffset(file, AF_DEFAULT_TRACK));
printf(" %d channel%s, %jd frames\n",
afGetChannels(file, AF_DEFAULT_TRACK),
afGetChannels(file, AF_DEFAULT_TRACK) > 1 ? "s" : "",
(intmax_t) afGetFrameCount(file, AF_DEFAULT_TRACK));
printf("Sampling Rate %.2f Hz\n", afGetRate(file, AF_DEFAULT_TRACK));
printf("Duration %.3f seconds\n",
afGetFrameCount(file, AF_DEFAULT_TRACK) /
afGetRate(file, AF_DEFAULT_TRACK));
char *copyright = copyrightstring(file);
if (copyright)
{
printf("Copyright %s\n", copyright);
free(copyright);
}
afCloseFile(file);
return true;
}
void testalaw (int fileFormat)
{
AFfilehandle file;
AFfilesetup setup;
uint16_t samples[] = {8, 24, 88, 120, 184, 784, 912, 976,
1120, 1440, 1888, 8960, 9984, 16128, 19968, 32256};
uint16_t readsamples[SAMPLE_COUNT];
AFframecount framesWritten, framesRead;
int i;
setup = afNewFileSetup();
afInitCompression(setup, AF_DEFAULT_TRACK, AF_COMPRESSION_G711_ALAW);
afInitFileFormat(setup, fileFormat);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
file = afOpenFile(TEST_FILE, "w", setup);
afFreeFileSetup(setup);
ensure(afGetCompression(file, AF_DEFAULT_TRACK) ==
AF_COMPRESSION_G711_ALAW,
"test file not created with G.711 A-law compression");
ensure(file != AF_NULL_FILEHANDLE, "unable to open file for writing");
framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, samples,
FRAME_COUNT);
ensure(framesWritten == FRAME_COUNT,
"number of frames requested does not match number of frames written");
afCloseFile(file);
/* Open the file for reading and verify the data. */
file = afOpenFile(TEST_FILE, "r", NULL);
ensure(file != AF_NULL_FILEHANDLE, "unable to open file for reading");
ensure(afGetFileFormat(file, NULL) == fileFormat,
"test file format incorrect");
ensure(afGetCompression(file, AF_DEFAULT_TRACK) ==
AF_COMPRESSION_G711_ALAW,
"test file not opened with G.711 A-law compression");
framesRead = afReadFrames(file, AF_DEFAULT_TRACK, readsamples,
FRAME_COUNT);
ensure(framesRead == FRAME_COUNT,
"number of frames read does not match number of frames requested");
#ifdef DEBUG
for (i=0; i<SAMPLE_COUNT; i++)
printf("readsamples[%d]: %d\n", i, readsamples[i]);
for (i=0; i<SAMPLE_COUNT; i++)
printf("samples[%d]: %d\n", i, samples[i]);
#endif
for (i=0; i<SAMPLE_COUNT; i++)
{
ensure(samples[i] == readsamples[i],
"data written does not match data read");
}
/* G.711 compression uses one byte per sample. */
ensure(afGetTrackBytes(file, AF_DEFAULT_TRACK) == SAMPLE_COUNT,
"track byte count is incorrect");
ensure(afGetFrameCount(file, AF_DEFAULT_TRACK) == FRAME_COUNT,
"frame count is incorrect");
ensure(afGetChannels(file, AF_DEFAULT_TRACK) == 1,
"channel count is incorrect");
ensure(afCloseFile(file) == 0, "error closing file");
cleanup();
}
Result process()
{
if (const YAML::Node *n = m_entry.FindValue(kSkip))
return kSkipped;
if (const YAML::Node *n = m_entry.FindValue(kPath))
{
n->GetScalar(m_path);
}
else
{
logerr("no path specified, line %d", n->GetMark().line);
return kManifestError;
}
if (const YAML::Node *n = m_entry.FindValue(kMD5Sum))
{
std::string md5 = md5sum(m_path);
std::string expectedMD5;
n->GetScalar(expectedMD5);
if (md5 != expectedMD5)
{
logerr("md5 checksum differs from expected value");
return kFailure;
}
}
AFfilehandle file = afOpenFile(m_path.c_str(), "r", NULL);
if (const YAML::Node *n = m_entry.FindValue(kInvalid))
{
if (!file)
return kSuccess;
logerr("opening invalid file did not fail as expected");
return kFailure;
}
if (!file)
{
logerr("could not open file");
return kFailure;
}
for (YAML::Iterator i = m_entry.begin(); i != m_entry.end(); ++i)
{
std::string key = i.first().to<std::string>();
std::string value = i.second().to<std::string>();
if (key == kFileFormat)
{
const char *fileFormat =
(const char *) afQueryPointer(AF_QUERYTYPE_FILEFMT,
AF_QUERY_LABEL, afGetFileFormat(file, NULL), 0, 0);
assert(fileFormat);
expect(key, std::string(fileFormat), value);
}
else if (key == kChannels)
{
int expectedChannels = atoi(value.c_str());
expect(key, expectedChannels,
afGetChannels(file, AF_DEFAULT_TRACK));
}
else if (key == kByteOrder)
{
int expectedByteOrder;
if (value == kByteOrder_Big)
expectedByteOrder = AF_BYTEORDER_BIGENDIAN;
else if (value == kByteOrder_Little)
expectedByteOrder = AF_BYTEORDER_LITTLEENDIAN;
else
{
logerr("bad value for byte order: %s, line %d",
value.c_str(),
i.second().GetMark().line);
return kManifestError;
}
expect(key, expectedByteOrder,
afGetByteOrder(file, AF_DEFAULT_TRACK));
}
else if (key == kSampleRate)
{
double expectedSampleRate = atof(value.c_str());
expect(key, expectedSampleRate,
afGetRate(file, AF_DEFAULT_TRACK));
}
else if (key == kSampleFormat)
{
std::string width = value.substr(1, value.length() - 1);
char format = value[0];
int expectedSampleWidth = atoi(width.c_str());
bool isValidSampleWidth =
(expectedSampleWidth >= 1 && expectedSampleWidth <= 32) ||
expectedSampleWidth == 64;
if (!isValidSampleWidth)
{
logerr("bad value for sample format: %s, line %d",
value.c_str(), i.second().GetMark().line);
return kManifestError;
}
int expectedSampleFormat = -1;
switch (format)
{
case 's':
expectedSampleFormat = AF_SAMPFMT_TWOSCOMP; break;
case 'u':
expectedSampleFormat = AF_SAMPFMT_UNSIGNED; break;
case 'f':
if (expectedSampleWidth == 32)
expectedSampleFormat = AF_SAMPFMT_FLOAT;
else if (expectedSampleWidth == 64)
expectedSampleFormat = AF_SAMPFMT_DOUBLE;
break;
default:
logerr("bad value for sample format: %s, line %d",
value.c_str(), i.second().GetMark().line);
return kManifestError;
}
int sampleFormat, sampleWidth;
afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
expect(key, expectedSampleFormat, sampleFormat);
expect(key, expectedSampleWidth, sampleWidth);
}
else if (key == kCompression)
{
int expectedCompression;
if (value == kCompression_None)
expectedCompression = AF_COMPRESSION_NONE;
else if (value == kCompression_IMA_ADPCM)
expectedCompression = AF_COMPRESSION_IMA;
else if (value == kCompression_MS_ADPCM)
expectedCompression = AF_COMPRESSION_MS_ADPCM;
else if (value == kCompression_ulaw)
expectedCompression = AF_COMPRESSION_G711_ULAW;
else if (value == kCompression_alaw)
expectedCompression = AF_COMPRESSION_G711_ALAW;
else if (value == kCompression_FLAC)
expectedCompression = AF_COMPRESSION_FLAC;
else if (value == kCompression_ALAC)
expectedCompression = AF_COMPRESSION_ALAC;
else
{
logerr("bad value for compression: %s, line %d",
value.c_str(), i.second().GetMark().line);
return kManifestError;
}
expect(key, expectedCompression,
afGetCompression(file, AF_DEFAULT_TRACK));
}
else if (key == kFrames)
{
AFframecount expectedFrameCount = atoll(value.c_str());
expect(key, expectedFrameCount,
afGetFrameCount(file, AF_DEFAULT_TRACK));
int bufferFrameCount = 1024;
int channels = afGetChannels(file, AF_DEFAULT_TRACK);
int maxBytesPerFrame = 8;
char *buffer = new char[channels * bufferFrameCount * maxBytesPerFrame];
AFframecount framesRead = 0;
while (framesRead < expectedFrameCount)
{
AFframecount framesToRead = std::min<AFframecount>(bufferFrameCount,
expectedFrameCount - framesRead);
AFframecount result = afReadFrames(file, AF_DEFAULT_TRACK,
buffer, framesToRead);
if (result != framesToRead)
{
m_failures++;
break;
}
framesRead += result;
}
delete [] buffer;
}
else if (key == kBytes)
{
AFfileoffset expectedTrackBytes = atoll(value.c_str());
expect(key, expectedTrackBytes,
afGetTrackBytes(file, AF_DEFAULT_TRACK));
}
}
afCloseFile(file);
return m_failures == 0 ? kSuccess : kFailure;
}
int main (int argc, char **argv)
{
int i = 1;
char *infilename, *outfilename;
int fileFormat, outFileFormat = AF_FILE_UNKNOWN;
AFfilehandle infile, outfile;
AFfilesetup outfilesetup;
int sampleFormat, sampleWidth, channelCount;
double sampleRate;
int outSampleFormat = -1, outSampleWidth = -1,
outChannelCount = -1;
double outMaxAmp = 1.0;
AFframecount totalFrames;
if (argc == 2)
{
if (!strcmp(argv[1], "--version") || !strcmp(argv[1], "-v"))
{
printversion();
exit(EXIT_SUCCESS);
}
if (!strcmp(argv[1], "--help") || !strcmp(argv[1], "-h"))
{
printusage();
exit(EXIT_SUCCESS);
}
}
if (argc < 3)
usageerror();
infilename = argv[1];
outfilename = argv[2];
i = 3;
while (i < argc)
{
if (!strcmp(argv[i], "format"))
{
if (i + 1 >= argc)
usageerror();
if (!strcmp(argv[i+1], "aiff"))
outFileFormat = AF_FILE_AIFF;
else if (!strcmp(argv[i+1], "aifc"))
outFileFormat = AF_FILE_AIFFC;
else if (!strcmp(argv[i+1], "wave"))
outFileFormat = AF_FILE_WAVE;
else if (!strcmp(argv[i+1], "next"))
outFileFormat = AF_FILE_NEXTSND;
else if (!strcmp(argv[i+1], "bics"))
outFileFormat = AF_FILE_BICSF;
else if (!strcmp(argv[i+1], "voc"))
outFileFormat = AF_FILE_VOC;
else if (!strcmp(argv[i+1], "nist"))
outFileFormat = AF_FILE_NIST_SPHERE;
else if (!strcmp(argv[i+1], "caf"))
outFileFormat = AF_FILE_CAF;
else
{
fprintf(stderr, "sfconvert: Unknown format %s.\n", argv[i+1]);
exit(EXIT_FAILURE);
}
/* Increment for argument. */
i++;
}
else if (!strcmp(argv[i], "channels"))
{
if (i + 1 >= argc)
usageerror();
outChannelCount = atoi(argv[i+1]);
if (outChannelCount < 1)
usageerror();
/* Increment for argument. */
i++;
}
else if (!strcmp(argv[i], "float"))
{
if (i + 1 >= argc)
usageerror();
outSampleFormat = AF_SAMPFMT_FLOAT;
outSampleWidth = 32;
outMaxAmp = atof(argv[i+1]);
/* Increment for argument. */
i++;
}
else if (!strcmp(argv[i], "integer"))
{
if (i + 2 >= argc)
usageerror();
outSampleWidth = atoi(argv[i+1]);
if (outSampleWidth < 1 || outSampleWidth > 32)
usageerror();
if (!strcmp(argv[i+2], "2scomp"))
outSampleFormat = AF_SAMPFMT_TWOSCOMP;
else if (!strcmp(argv[i+2], "unsigned"))
outSampleFormat = AF_SAMPFMT_UNSIGNED;
else
usageerror();
/* Increment for arguments. */
i += 2;
}
else
{
printf("Unrecognized command %s\n", argv[i]);
}
i++;
}
infile = afOpenFile(infilename, "r", AF_NULL_FILESETUP);
if (infile == AF_NULL_FILEHANDLE)
{
printf("Could not open file '%s' for reading.\n", infilename);
return 1;
}
/* Get audio format parameters from input file. */
fileFormat = afGetFileFormat(infile, NULL);
totalFrames = afGetFrameCount(infile, AF_DEFAULT_TRACK);
channelCount = afGetChannels(infile, AF_DEFAULT_TRACK);
sampleRate = afGetRate(infile, AF_DEFAULT_TRACK);
afGetSampleFormat(infile, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
/* Initialize output audio format parameters. */
outfilesetup = afNewFileSetup();
if (outFileFormat == -1)
outFileFormat = fileFormat;
if (outSampleFormat == -1 || outSampleWidth == -1)
{
outSampleFormat = sampleFormat;
outSampleWidth = sampleWidth;
}
if (outChannelCount == -1)
outChannelCount = channelCount;
afInitFileFormat(outfilesetup, outFileFormat);
afInitSampleFormat(outfilesetup, AF_DEFAULT_TRACK, outSampleFormat,
outSampleWidth);
afInitChannels(outfilesetup, AF_DEFAULT_TRACK, outChannelCount);
afInitRate(outfilesetup, AF_DEFAULT_TRACK, sampleRate);
outfile = afOpenFile(outfilename, "w", outfilesetup);
if (outfile == AF_NULL_FILEHANDLE)
{
printf("Could not open file '%s' for writing.\n", outfilename);
return 1;
}
/*
Set the output file's virtual audio format parameters
to match the audio format parameters of the input file.
*/
afSetVirtualChannels(outfile, AF_DEFAULT_TRACK, channelCount);
afSetVirtualSampleFormat(outfile, AF_DEFAULT_TRACK, sampleFormat,
sampleWidth);
afFreeFileSetup(outfilesetup);
copyaudiodata(infile, outfile, AF_DEFAULT_TRACK, totalFrames);
afCloseFile(infile);
afCloseFile(outfile);
printfileinfo(infilename);
putchar('\n');
printfileinfo(outfilename);
return EXIT_SUCCESS;
}
int main (int argc, char **argv)
{
AFfilehandle file;
AFfilesetup setup;
uint16_t samples[] = {11, 51, 101, 501, 1001, 5001, 10001, 50001};
int i;
int sampleFormat, sampleWidth;
int framesRead, framesWritten;
int nativeByteOrder;
#ifdef WORDS_BIGENDIAN
nativeByteOrder = AF_BYTEORDER_BIGENDIAN;
#else
nativeByteOrder = AF_BYTEORDER_LITTLEENDIAN;
#endif
setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_RAWDATA);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
ensure(createTemporaryFile("writeraw", sTestFileName),
"could not create temporary file");
file = afOpenFile(sTestFileName, "w", setup);
ensure(file != AF_NULL_FILEHANDLE, "unable to open file for writing");
framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, samples, 8);
ensure(framesWritten == 8,
"number of frames written does not match number of frames requested");
ensure(afCloseFile(file) == 0, "error closing file");
file = afOpenFile(sTestFileName, "r", setup);
ensure(file != AF_NULL_FILEHANDLE, "unable to open file for reading");
afFreeFileSetup(setup);
ensure(afGetFileFormat(file, NULL) == AF_FILE_RAWDATA,
"test file not created as raw audio data file");
afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
ensure(sampleFormat == AF_SAMPFMT_TWOSCOMP,
"test file not two's complement");
ensure(sampleWidth == 16,
"test file sample format is not 16-bit");
ensure(afGetChannels(file, AF_DEFAULT_TRACK) == 1,
"test file doesn't have exactly one channel");
ensure(afGetByteOrder(file, AF_DEFAULT_TRACK) == nativeByteOrder,
"test file not in native byte order");
for (i=0; i<8; i++)
{
uint16_t temporary;
framesRead = afReadFrames(file, AF_DEFAULT_TRACK, &temporary, 1);
ensure(framesRead == 1,
"number of frames read does not match number of frames requested");
ensure(temporary == samples[i],
"data written to file doesn't match data read from file");
}
ensure(afCloseFile(file) == 0, "error closing file");
cleanup();
printf("writeraw test passed.\n");
exit(EXIT_SUCCESS);
}
void runTestWithChannels(int fileFormat, int channelCount)
{
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("PCMData", &testFileName));
const int numFrames = 20;
const int numSamples = numFrames * channelCount;
T samples[numSamples];
for (int i=0; i<numFrames; i++)
for (int c=0; c<channelCount; c++)
samples[i*channelCount + c] = static_cast<T>(i*i + 3*c + 1);
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, fileFormat);
afInitChannels(setup, AF_DEFAULT_TRACK, channelCount);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, kSampleFormat, kBitsPerSample);
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_TRUE(file) << "Could not open file for writing";
afFreeFileSetup(setup);
PCMMapping mapping, defaultMapping;
getDefaultPCMMapping(kSampleFormat, kBitsPerSample, defaultMapping);
afGetPCMMapping(file, AF_DEFAULT_TRACK,
&mapping.slope, &mapping.intercept, &mapping.minClip, &mapping.maxClip);
ASSERT_EQ(mapping.slope, defaultMapping.slope);
ASSERT_EQ(mapping.intercept, defaultMapping.intercept);
ASSERT_EQ(mapping.minClip, defaultMapping.minClip);
ASSERT_EQ(mapping.maxClip, defaultMapping.maxClip);
afGetVirtualPCMMapping(file, AF_DEFAULT_TRACK,
&mapping.slope, &mapping.intercept, &mapping.minClip, &mapping.maxClip);
ASSERT_EQ(mapping.slope, defaultMapping.slope);
ASSERT_EQ(mapping.intercept, defaultMapping.intercept);
ASSERT_EQ(mapping.minClip, defaultMapping.minClip);
ASSERT_EQ(mapping.maxClip, defaultMapping.maxClip);
ASSERT_EQ(afWriteFrames(file, AF_DEFAULT_TRACK, samples, numFrames),
numFrames) <<
"Number of frames written does not match number of frames requested";
ASSERT_EQ(afCloseFile(file), 0) << "Error closing file";
file = afOpenFile(testFileName.c_str(), "r", NULL);
ASSERT_TRUE(file) << "Could not open file for reading";
ASSERT_EQ(afGetFileFormat(file, NULL), fileFormat) <<
"Incorrect file format";
int sampleFormat, sampleWidth;
afGetSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat, &sampleWidth);
ASSERT_EQ(sampleFormat, kSampleFormat) << "Incorrect sample format";
ASSERT_EQ(sampleWidth, kBitsPerSample) << "Incorrect sample width";
ASSERT_EQ(afGetChannels(file, AF_DEFAULT_TRACK), channelCount) <<
"Incorrect number of channels";
afGetPCMMapping(file, AF_DEFAULT_TRACK,
&mapping.slope, &mapping.intercept, &mapping.minClip, &mapping.maxClip);
ASSERT_EQ(mapping.slope, defaultMapping.slope);
ASSERT_EQ(mapping.intercept, defaultMapping.intercept);
ASSERT_EQ(mapping.minClip, defaultMapping.minClip);
ASSERT_EQ(mapping.maxClip, defaultMapping.maxClip);
afGetVirtualPCMMapping(file, AF_DEFAULT_TRACK,
&mapping.slope, &mapping.intercept, &mapping.minClip, &mapping.maxClip);
ASSERT_EQ(mapping.slope, defaultMapping.slope);
ASSERT_EQ(mapping.intercept, defaultMapping.intercept);
ASSERT_EQ(mapping.minClip, defaultMapping.minClip);
ASSERT_EQ(mapping.maxClip, defaultMapping.maxClip);
T *samplesRead = new T[numSamples];
ASSERT_EQ(afReadFrames(file, AF_DEFAULT_TRACK, samplesRead, numFrames),
numFrames) <<
"Number of frames read does not match number of frames requested";
for (int i=0; i<numSamples; i++)
ASSERT_EQ(samplesRead[i], samples[i]) <<
"Data read from file does not match data written";
delete [] samplesRead;
ASSERT_EQ(afCloseFile(file), 0) << "Error closing file";
ASSERT_EQ(::unlink(testFileName.c_str()), 0);
}
