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);
}
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();
}
static void testADPCM(int fileFormat, int compressionFormat, int channelCount,
int bytesPerPacket, int framesPerPacket, int frameCount, int threshold)
{
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("ADPCM", &testFileName));
AFfilesetup setup = afNewFileSetup();
afInitFileFormat(setup, fileFormat);
afInitChannels(setup, AF_DEFAULT_TRACK, channelCount);
afInitCompression(setup, AF_DEFAULT_TRACK, compressionFormat);
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_TRUE(file);
afFreeFileSetup(setup);
int16_t *data = new int16_t[frameCount * channelCount];
for (int i=0; i<frameCount; i++)
for (int c=0; c<channelCount; c++)
data[i*channelCount + c] = i * ((c&1) ? -1 : 1);
AFframecount framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, data, frameCount);
ASSERT_EQ(framesWritten, frameCount);
ASSERT_EQ(afCloseFile(file), 0);
file = afOpenFile(testFileName.c_str(), "r", AF_NULL_FILESETUP);
ASSERT_TRUE(file);
ASSERT_EQ(afGetCompression(file, AF_DEFAULT_TRACK), compressionFormat);
ASSERT_EQ(afGetFrameCount(file, AF_DEFAULT_TRACK), frameCount);
ASSERT_EQ(afGetTrackBytes(file, AF_DEFAULT_TRACK),
(bytesPerPacket * frameCount) / framesPerPacket);
int16_t *readData = new int16_t[frameCount * channelCount];
AFframecount framesRead = afReadFrames(file, AF_DEFAULT_TRACK, readData, frameCount);
ASSERT_EQ(framesRead, frameCount);
for (int i=0; i<frameCount; i++)
for (int c=0; c<channelCount; c++)
EXPECT_LE(std::abs(data[i*channelCount + c] - readData[i*channelCount + c]), threshold);
int16_t *offsetReadData = new int16_t[frameCount * channelCount];
// Read entire file with a seek before each read operation.
for (AFframecount offset = 0; offset < frameCount; offset += framesPerPacket + 3)
{
ASSERT_EQ(afSeekFrame(file, AF_DEFAULT_TRACK, offset), offset);
AFframecount framesToRead = 1091;
framesRead = afReadFrames(file, AF_DEFAULT_TRACK, offsetReadData, framesToRead);
ASSERT_EQ(framesRead, std::min(framesToRead, frameCount - offset));
for (int i=0; i<framesRead; i++)
for (int c=0; c<channelCount; c++)
EXPECT_EQ(readData[(i+offset)*channelCount + c],
offsetReadData[i*channelCount + c]);
}
// Read entire file sequentially in multiple read operations.
ASSERT_EQ(afSeekFrame(file, AF_DEFAULT_TRACK, 0), 0);
AFframecount framesToRead = 1087;
for (AFframecount offset = 0; offset < frameCount; offset += framesToRead)
{
framesRead = afReadFrames(file, AF_DEFAULT_TRACK, offsetReadData, framesToRead);
ASSERT_EQ(framesRead, std::min(framesToRead, frameCount - offset));
for (int i=0; i<framesRead; i++)
for (int c=0; c<channelCount; c++)
EXPECT_EQ(readData[(i+offset)*channelCount + c],
offsetReadData[i*channelCount + c]);
}
ASSERT_EQ(afCloseFile(file), 0);
delete [] data;
delete [] readData;
delete [] offsetReadData;
ASSERT_EQ(::unlink(testFileName.c_str()), 0);
}
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;
}
