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);
}
}
OSStatus fileRenderProc (void *inRefCon,
AudioUnitRenderActionFlags *inActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumFrames,
AudioBufferList *ioData)
{
AFfilehandle file = (AFfilehandle) inRefCon;
AFframecount framesToRead, framesRead;
framesToRead = inNumFrames;
if (framesToRead > BUFFER_FRAME_COUNT)
framesToRead = BUFFER_FRAME_COUNT;
framesRead = afReadFrames(file, AF_DEFAULT_TRACK,
buffer, framesToRead);
if (framesRead > 0)
{
ioData->mBuffers[0].mData = buffer;
ioData->mBuffers[0].mDataByteSize = framesRead *
afGetVirtualFrameSize(file, AF_DEFAULT_TRACK, 1);
}
else
isPlaying = 0;
return noErr;
}
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);
}
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();
}
/*
Copy audio data from one file to another. This function
assumes that the virtual sample formats of the two files
match.
*/
int copyaudiodata (AFfilehandle infile, AFfilehandle outfile, int trackid,
AFframecount totalFrameCount)
{
AFframecount totalFramesWritten = 0;
void *buffer;
int frameSize;
bool ok = true, done = false;
frameSize = afGetVirtualFrameSize(infile, trackid, 1);
buffer = malloc(BUFFER_FRAME_COUNT * frameSize);
while (!done)
{
AFframecount framesToRead = BUFFER_FRAME_COUNT;
AFframecount framesRead, framesWritten;
framesRead = afReadFrames(infile, trackid, buffer,
framesToRead);
if (framesRead < 0)
{
fprintf(stderr, "Bad read of audio track data.\n");
ok = false;
done = true;
}
framesWritten = afWriteFrames(outfile, trackid, buffer,
framesRead);
if (framesWritten < 0)
{
fprintf(stderr, "Bad write of audio track data.\n");
ok = false;
done = true;
}
else
{
totalFramesWritten += framesWritten;
}
if (totalFramesWritten == totalFrameCount)
done = true;
}
free(buffer);
return ok;
}
TEST_F(SignConversionTest, Int16)
{
AFfilehandle file = createTestFile(16);
const int16_t data[] = { kMinInt16, 0, kMaxInt16 };
const int frameCount = sizeof (data) / sizeof (data[0]);
AFframecount framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, data, frameCount);
ASSERT_EQ(framesWritten, frameCount);
afCloseFile(file);
file = openTestFile(16);
ASSERT_TRUE(file != NULL);
uint16_t readData[frameCount];
AFframecount framesRead = afReadFrames(file, AF_DEFAULT_TRACK, readData, frameCount);
ASSERT_EQ(framesRead, frameCount);
afCloseFile(file);
const uint16_t expectedData[] = { 0, -kMinInt16, kMaxUInt16 };
for (int i=0; i<frameCount; i++)
EXPECT_EQ(readData[i], expectedData[i]);
}
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;
}
TEST_F(PCMMappingTest, Double)
{
AFfilehandle file = createTestFile(AF_SAMPFMT_DOUBLE, 64);
const double data[] = { -1, 0, 1 };
const int frameCount = sizeof (data) / sizeof (data[0]);
AFframecount framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, data, frameCount);
ASSERT_EQ(framesWritten, frameCount);
afCloseFile(file);
file = openTestFile();
ASSERT_TRUE(file != NULL);
double slope = 2, intercept = 2, minClip = 0, maxClip = 4;
afSetVirtualPCMMapping(file, AF_DEFAULT_TRACK, slope, intercept, minClip, maxClip);
double readData[frameCount];
AFframecount framesRead = afReadFrames(file, AF_DEFAULT_TRACK, readData, frameCount);
ASSERT_EQ(framesRead, frameCount);
afCloseFile(file);
const double expectedData[] = { 0, 2, 4 };
for (int i=0; i<frameCount; i++)
EXPECT_EQ(readData[i], expectedData[i]);
}
boolByte readBlockFromAudiofile(void* sampleSourcePtr, SampleBuffer sampleBuffer) {
SampleSource sampleSource = (SampleSource)sampleSourcePtr;
SampleSourceAudiofileData extraData = (SampleSourceAudiofileData)(sampleSource->extraData);
int numFramesRead;
int currentInterlacedSample = 0;
int currentDeinterlacedSample = 0;
int currentChannel;
if(extraData->interlacedBuffer == NULL) {
extraData->interlacedBuffer = (float*)malloc(sizeof(float) * getNumChannels() * getBlocksize());
}
memset(extraData->interlacedBuffer, 0, sizeof(float) * getNumChannels() * getBlocksize());
numFramesRead = afReadFrames(extraData->fileHandle, AF_DEFAULT_TRACK, extraData->interlacedBuffer, getBlocksize());
// Loop over the number of frames wanted, not the number we actually got. This means that the last block will
// be partial, but then we write empty data to the end, since the interlaced buffer gets cleared above.
while(currentInterlacedSample < getBlocksize() * getNumChannels()) {
for(currentChannel = 0; currentChannel < sampleBuffer->numChannels; currentChannel++) {
sampleBuffer->samples[currentChannel][currentDeinterlacedSample] = extraData->interlacedBuffer[currentInterlacedSample++];
}
currentDeinterlacedSample++;
}
sampleSource->numSamplesProcessed += numFramesRead;
if(numFramesRead == 0) {
logDebug("End of audio file reached");
return false;
}
else if(numFramesRead < 0) {
logError("Error reading audio file");
return false;
}
else {
return true;
}
}
//***************************************************************************
bool Kwave::AudiofileDecoder::decode(QWidget */*widget*/,
Kwave::MultiWriter &dst)
{
Q_ASSERT(m_src_adapter);
Q_ASSERT(m_source);
if (!m_source) return false;
if (!m_src_adapter) return false;
AFfilehandle fh = m_src_adapter->handle();
Q_ASSERT(fh);
if (!fh) return false;
unsigned int frame_size = Kwave::toUint(
afGetVirtualFrameSize(fh, AF_DEFAULT_TRACK, 1));
// allocate a buffer for input data
const unsigned int buffer_frames = (8 * 1024);
sample_storage_t *buffer =
static_cast<sample_storage_t *>(malloc(buffer_frames * frame_size));
Q_ASSERT(buffer);
if (!buffer) return false;
// read in from the audiofile source
const unsigned int tracks = Kwave::FileInfo(metaData()).tracks();
sample_index_t rest = Kwave::FileInfo(metaData()).length();
while (rest) {
unsigned int frames = buffer_frames;
if (frames > rest) frames = Kwave::toUint(rest);
int buffer_used = afReadFrames(fh,
AF_DEFAULT_TRACK, reinterpret_cast<char *>(buffer), frames);
// break if eof reached
if (buffer_used <= 0) break;
rest -= buffer_used;
// split into the tracks
sample_storage_t *p = buffer;
unsigned int count = buffer_used;
while (count) {
for (unsigned int track = 0; track < tracks; track++) {
sample_storage_t s = *p++;
// adjust precision
if (SAMPLE_STORAGE_BITS != SAMPLE_BITS) {
s /= (1 << (SAMPLE_STORAGE_BITS - SAMPLE_BITS));
}
// the following cast is only necessary if
// sample_t is not equal to a quint32
*(dst[track]) << static_cast<sample_t>(s);
}
--count;
}
// abort if the user pressed cancel
if (dst.isCanceled()) break;
}
// return with a valid Signal, even if the user pressed cancel !
if (buffer) free(buffer);
return true;
}
int main(int argc, char *argv[])
{
fsk_tx_state_t *caller_tx;
fsk_rx_state_t *caller_rx;
fsk_tx_state_t *answerer_tx;
fsk_rx_state_t *answerer_rx;
bert_state_t caller_bert;
bert_state_t answerer_bert;
bert_results_t bert_results;
power_meter_t caller_meter;
power_meter_t answerer_meter;
int16_t caller_amp[BLOCK_LEN];
int16_t answerer_amp[BLOCK_LEN];
int16_t caller_model_amp[BLOCK_LEN];
int16_t answerer_model_amp[BLOCK_LEN];
int16_t out_amp[2*BLOCK_LEN];
AFfilehandle inhandle;
AFfilehandle outhandle;
int outframes;
int i;
int j;
int samples;
int test_bps;
int noise_level;
int noise_sweep;
int bits_per_test;
int line_model_no;
int modem_under_test_1;
int modem_under_test_2;
int modems_set;
int log_audio;
int channel_codec;
int rbs_pattern;
int on_at;
int off_at;
tone_gen_descriptor_t tone_desc;
tone_gen_state_t tone_tx;
int opt;
channel_codec = MUNGE_CODEC_NONE;
rbs_pattern = 0;
line_model_no = 0;
decode_test_file = NULL;
noise_sweep = FALSE;
modem_under_test_1 = FSK_V21CH1;
modem_under_test_2 = FSK_V21CH2;
log_audio = FALSE;
modems_set = 0;
while ((opt = getopt(argc, argv, "c:dlm:nr:s:")) != -1)
{
switch (opt)
{
case 'c':
channel_codec = atoi(optarg);
break;
case 'd':
decode_test_file = optarg;
break;
case 'l':
log_audio = TRUE;
break;
case 'm':
line_model_no = atoi(optarg);
break;
case 'n':
noise_sweep = TRUE;
break;
case 'r':
rbs_pattern = atoi(optarg);
break;
case 's':
switch (modems_set++)
{
case 0:
modem_under_test_1 = atoi(optarg);
break;
case 1:
modem_under_test_2 = atoi(optarg);
break;
}
break;
default:
//usage();
exit(2);
break;
}
}
if (modem_under_test_1 >= 0)
printf("Modem channel 1 is '%s'\n", preset_fsk_specs[modem_under_test_1].name);
if (modem_under_test_2 >= 0)
printf("Modem channel 2 is '%s'\n", preset_fsk_specs[modem_under_test_2].name);
outhandle = AF_NULL_FILEHANDLE;
if (log_audio)
{
if ((outhandle = afOpenFile_telephony_write(OUTPUT_FILE_NAME, 2)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot create wave file '%s'\n", OUTPUT_FILE_NAME);
exit(2);
}
}
noise_level = -200;
bits_per_test = 0;
inhandle = NULL;
memset(caller_amp, 0, sizeof(*caller_amp));
memset(answerer_amp, 0, sizeof(*answerer_amp));
memset(caller_model_amp, 0, sizeof(*caller_model_amp));
memset(answerer_model_amp, 0, sizeof(*answerer_model_amp));
power_meter_init(&caller_meter, 7);
power_meter_init(&answerer_meter, 7);
if (decode_test_file)
{
if ((inhandle = afOpenFile_telephony_read(decode_test_file, 1)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", decode_test_file);
exit(2);
}
caller_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_1], TRUE, put_bit, NULL);
fsk_rx_set_modem_status_handler(caller_rx, rx_status, (void *) &caller_rx);
test_bps = preset_fsk_specs[modem_under_test_1].baud_rate;
for (;;)
{
samples = afReadFrames(inhandle,
AF_DEFAULT_TRACK,
caller_model_amp,
BLOCK_LEN);
if (samples < BLOCK_LEN)
break;
for (i = 0; i < samples; i++)
power_meter_update(&caller_meter, caller_model_amp[i]);
fsk_rx(caller_rx, caller_model_amp, samples);
}
if (afCloseFile(inhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", decode_test_file);
exit(2);
}
}
else
{
printf("Test cutoff level\n");
caller_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_1], TRUE, cutoff_test_put_bit, NULL);
fsk_rx_signal_cutoff(caller_rx, -30.0f);
fsk_rx_set_modem_status_handler(caller_rx, cutoff_test_rx_status, (void *) &caller_rx);
on_at = 0;
for (i = -40; i < -25; i++)
{
make_tone_gen_descriptor(&tone_desc,
1500,
i,
0,
0,
1,
0,
0,
0,
TRUE);
tone_gen_init(&tone_tx, &tone_desc);
for (j = 0; j < 10; j++)
{
samples = tone_gen(&tone_tx, caller_model_amp, 160);
fsk_rx(caller_rx, caller_model_amp, samples);
}
if (cutoff_test_carrier)
break;
}
on_at = i;
off_at = 0;
for ( ; i > -40; i--)
{
make_tone_gen_descriptor(&tone_desc,
1500,
i,
0,
0,
1,
0,
0,
0,
TRUE);
tone_gen_init(&tone_tx, &tone_desc);
for (j = 0; j < 10; j++)
{
samples = tone_gen(&tone_tx, caller_model_amp, 160);
fsk_rx(caller_rx, caller_model_amp, samples);
}
if (!cutoff_test_carrier)
break;
}
off_at = i;
printf("Carrier on at %d, off at %d\n", on_at, off_at);
if (on_at < -29 || on_at > -26
||
off_at < -35 || off_at > -31)
{
printf("Tests failed.\n");
exit(2);
}
printf("Test with BERT\n");
test_bps = preset_fsk_specs[modem_under_test_1].baud_rate;
if (modem_under_test_1 >= 0)
{
caller_tx = fsk_tx_init(NULL, &preset_fsk_specs[modem_under_test_1], (get_bit_func_t) bert_get_bit, &caller_bert);
fsk_tx_set_modem_status_handler(caller_tx, tx_status, (void *) &caller_tx);
answerer_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_1], TRUE, (put_bit_func_t) bert_put_bit, &answerer_bert);
fsk_rx_set_modem_status_handler(answerer_rx, rx_status, (void *) &answerer_rx);
}
if (modem_under_test_2 >= 0)
{
answerer_tx = fsk_tx_init(NULL, &preset_fsk_specs[modem_under_test_2], (get_bit_func_t) bert_get_bit, &answerer_bert);
fsk_tx_set_modem_status_handler(answerer_tx, tx_status, (void *) &answerer_tx);
caller_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_2], TRUE, (put_bit_func_t) bert_put_bit, &caller_bert);
fsk_rx_set_modem_status_handler(caller_rx, rx_status, (void *) &caller_rx);
}
test_bps = preset_fsk_specs[modem_under_test_1].baud_rate;
bits_per_test = 500000;
noise_level = -24;
bert_init(&caller_bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&caller_bert, 100000, reporter, (void *) (intptr_t) 1);
bert_init(&answerer_bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&answerer_bert, 100000, reporter, (void *) (intptr_t) 2);
if ((model = both_ways_line_model_init(line_model_no, (float) noise_level, line_model_no, (float) noise_level, channel_codec, rbs_pattern)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
for (;;)
{
samples = fsk_tx(caller_tx, caller_amp, BLOCK_LEN);
for (i = 0; i < samples; i++)
power_meter_update(&caller_meter, caller_amp[i]);
samples = fsk_tx(answerer_tx, answerer_amp, BLOCK_LEN);
for (i = 0; i < samples; i++)
power_meter_update(&answerer_meter, answerer_amp[i]);
both_ways_line_model(model,
caller_model_amp,
caller_amp,
answerer_model_amp,
answerer_amp,
samples);
//printf("Powers %10.5fdBm0 %10.5fdBm0\n", power_meter_current_dbm0(&caller_meter), power_meter_current_dbm0(&answerer_meter));
fsk_rx(answerer_rx, caller_model_amp, samples);
for (i = 0; i < samples; i++)
out_amp[2*i] = caller_model_amp[i];
for ( ; i < BLOCK_LEN; i++)
out_amp[2*i] = 0;
fsk_rx(caller_rx, answerer_model_amp, samples);
for (i = 0; i < samples; i++)
out_amp[2*i + 1] = answerer_model_amp[i];
for ( ; i < BLOCK_LEN; i++)
out_amp[2*i + 1] = 0;
if (log_audio)
{
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
out_amp,
BLOCK_LEN);
if (outframes != BLOCK_LEN)
{
fprintf(stderr, " Error writing wave file\n");
exit(2);
}
}
if (samples < BLOCK_LEN)
{
bert_result(&caller_bert, &bert_results);
fprintf(stderr, "%ddB AWGN, %d bits, %d bad bits, %d resyncs\n", noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
if (!noise_sweep)
{
if (bert_results.total_bits != bits_per_test - 43
||
bert_results.bad_bits != 0
||
bert_results.resyncs != 0)
{
printf("Tests failed.\n");
exit(2);
}
}
bert_result(&answerer_bert, &bert_results);
fprintf(stderr, "%ddB AWGN, %d bits, %d bad bits, %d resyncs\n", noise_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
if (!noise_sweep)
{
if (bert_results.total_bits != bits_per_test - 43
||
bert_results.bad_bits != 0
||
bert_results.resyncs != 0)
{
printf("Tests failed.\n");
exit(2);
}
break;
}
/* Put a little silence between the chunks in the file. */
memset(out_amp, 0, sizeof(out_amp));
if (log_audio)
{
for (i = 0; i < 200; i++)
{
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
out_amp,
BLOCK_LEN);
}
}
if (modem_under_test_1 >= 0)
{
caller_tx = fsk_tx_init(NULL, &preset_fsk_specs[modem_under_test_1], (get_bit_func_t) bert_get_bit, &caller_bert);
fsk_tx_set_modem_status_handler(caller_tx, tx_status, (void *) &caller_tx);
answerer_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_1], TRUE, (put_bit_func_t) bert_put_bit, &answerer_bert);
fsk_rx_set_modem_status_handler(answerer_rx, rx_status, (void *) &answerer_rx);
}
if (modem_under_test_2 >= 0)
{
answerer_tx = fsk_tx_init(NULL, &preset_fsk_specs[modem_under_test_2], (get_bit_func_t) bert_get_bit, &answerer_bert);
fsk_tx_set_modem_status_handler(answerer_tx, tx_status, (void *) &answerer_tx);
caller_rx = fsk_rx_init(NULL, &preset_fsk_specs[modem_under_test_2], TRUE, (put_bit_func_t) bert_put_bit, &caller_bert);
fsk_rx_set_modem_status_handler(caller_rx, rx_status, (void *) &caller_rx);
}
noise_level++;
if ((model = both_ways_line_model_init(line_model_no, (float) noise_level, line_model_no, noise_level, channel_codec, 0)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
bert_init(&caller_bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&caller_bert, 100000, reporter, (void *) (intptr_t) 1);
bert_init(&answerer_bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&answerer_bert, 100000, reporter, (void *) (intptr_t) 2);
}
}
printf("Tests passed.\n");
}
if (log_audio)
{
if (afCloseFile(outhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", OUTPUT_FILE_NAME);
exit(2);
}
}
return 0;
}
int main(int argc, char *argv[])
{
AFfilehandle inhandle;
AFfilehandle outhandle;
AFfilesetup filesetup;
plc_state_t plc;
int inframes;
int outframes;
int16_t amp[1024];
int block_no;
int lost_blocks;
int block_len;
int loss_rate;
int dropit;
int block_real;
int block_synthetic;
int tone;
int i;
uint32_t phase_acc;
int32_t phase_rate;
loss_rate = 25;
block_len = 160;
block_real = FALSE;
block_synthetic = FALSE;
tone = -1;
for (i = 1; i < argc; i++)
{
if (strcmp(argv[i], "-l") == 0)
{
loss_rate = atoi(argv[++i]);
continue;
}
if (strcmp(argv[i], "-b") == 0)
{
block_len = atoi(argv[++i]);
continue;
}
if (strcmp(argv[i], "-t") == 0)
{
tone = atoi(argv[++i]);
continue;
}
if (strcmp(argv[i], "-r") == 0)
block_real = TRUE;
if (strcmp(argv[i], "-s") == 0)
block_synthetic = TRUE;
}
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);
phase_rate = 0;
inhandle = NULL;
if (tone < 0)
{
if ((inhandle = afOpenFile(INPUT_FILE_NAME, "r", NULL)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Failed to open wave file '%s'\n", INPUT_FILE_NAME);
exit(2);
}
}
else
{
phase_rate = dds_phase_ratef((float) tone);
}
if ((outhandle = afOpenFile(OUTPUT_FILE_NAME, "w", filesetup)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Failed to open wave file '%s'\n", OUTPUT_FILE_NAME);
exit(2);
}
plc_init(&plc);
lost_blocks = 0;
for (block_no = 0; ; block_no++)
{
if (tone < 0)
{
inframes = afReadFrames(inhandle,
AF_DEFAULT_TRACK,
amp,
block_len);
if (inframes != block_len)
break;
}
else
{
if (block_no > 10000)
break;
for (i = 0; i < block_len; i++)
amp[i] = (int16_t) dds_modf(&phase_acc, phase_rate, 10000.0, 0);
inframes = block_len;
}
dropit = rand()/(RAND_MAX/100);
if (dropit > loss_rate)
{
plc_rx(&plc, amp, inframes);
if (block_real)
memset(amp, 0, sizeof(int16_t)*inframes);
}
else
{
lost_blocks++;
plc_fillin(&plc, amp, inframes);
if (block_synthetic)
memset(amp, 0, sizeof(int16_t)*inframes);
}
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
amp,
inframes);
if (outframes != inframes)
{
fprintf(stderr, " Error writing out sound\n");
exit(2);
}
}
printf("Dropped %d of %d blocks\n", lost_blocks, block_no);
if (tone < 0)
{
if (afCloseFile(inhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", INPUT_FILE_NAME);
exit(2);
}
}
if (afCloseFile(outhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", OUTPUT_FILE_NAME);
exit(2);
}
afFreeFileSetup(filesetup);
return 0;
}
TEST(Seek, Seek)
{
std::string testFileName;
ASSERT_TRUE(createTemporaryFile("Seek", &testFileName));
const int kFrameCount = 2000;
const int kPadFrameCount = kFrameCount + 5;
const int kDataLength = kFrameCount * sizeof (int16_t);
int16_t data[kFrameCount];
int16_t readData[kPadFrameCount];
AFfilesetup setup = afNewFileSetup();
ASSERT_TRUE(setup);
afInitFileFormat(setup, AF_FILE_AIFF);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
AFfilehandle file = afOpenFile(testFileName.c_str(), "w", setup);
ASSERT_TRUE(file) << "could not open file for writing";
afFreeFileSetup(setup);
/* Initialize data to a nontrivial test pattern. */
for (int i=0; i<kFrameCount; i++)
{
if ((i%2) != 0)
data[i] = i;
else
data[i] = -i;
}
ASSERT_EQ(afWriteFrames(file, AF_DEFAULT_TRACK, data, kFrameCount),
kFrameCount);
afCloseFile(file);
file = afOpenFile(testFileName.c_str(), "r", AF_NULL_FILESETUP);
ASSERT_TRUE(file) << "Could not open file for reading";
/*
For each position in the file, seek to that position and
read to the end of the file, checking that the data read
matches the data written.
*/
for (int i=0; i<kFrameCount; i++)
{
memset(readData, 0, kDataLength);
AFfileoffset currentposition = afSeekFrame(file, AF_DEFAULT_TRACK, i);
ASSERT_EQ(currentposition, i) << "Incorrect seek position";
AFframecount framesread = afReadFrames(file, AF_DEFAULT_TRACK,
readData + i, kPadFrameCount);
ASSERT_EQ(framesread, kFrameCount - i) <<
"Incorrect number of frames read";
ASSERT_TRUE(!memcmp(data + i, readData + i,
framesread * sizeof (int16_t))) <<
"Error in data read";
}
afCloseFile(file);
ASSERT_EQ(::unlink(testFileName.c_str()), 0);
}
int main(int argc, char *argv[])
{
v27ter_rx_state_t rx;
v27ter_tx_state_t tx;
bert_results_t bert_results;
int16_t gen_amp[BLOCK_LEN];
int16_t amp[BLOCK_LEN];
AFfilehandle inhandle;
AFfilehandle outhandle;
AFfilesetup filesetup;
int outframes;
int samples;
int tep;
int test_bps;
int noise_level;
int signal_level;
int bits_per_test;
int line_model_no;
int block;
int log_audio;
int channel_codec;
int rbs_pattern;
float x;
int opt;
channel_codec = MUNGE_CODEC_NONE;
rbs_pattern = 0;
test_bps = 4800;
tep = FALSE;
line_model_no = 0;
decode_test_file = NULL;
use_gui = FALSE;
noise_level = -70;
signal_level = -13;
bits_per_test = 50000;
log_audio = FALSE;
while ((opt = getopt(argc, argv, "b:c:d:glm:n:r:s:t")) != -1)
{
switch (opt)
{
case 'b':
bits_per_test = atoi(optarg);
break;
case 'c':
channel_codec = atoi(optarg);
break;
case 'd':
decode_test_file = optarg;
break;
case 'g':
#if defined(ENABLE_GUI)
use_gui = TRUE;
#else
fprintf(stderr, "Graphical monitoring not available\n");
exit(2);
#endif
break;
case 'l':
log_audio = TRUE;
break;
case 'm':
line_model_no = atoi(optarg);
break;
case 'n':
noise_level = atoi(optarg);
break;
case 'r':
rbs_pattern = atoi(optarg);
break;
case 's':
signal_level = atoi(optarg);
break;
case 't':
tep = TRUE;
break;
default:
//usage();
exit(2);
break;
}
}
argc -= optind;
argv += optind;
if (argc > 0)
{
if (strcmp(argv[0], "4800") == 0)
test_bps = 4800;
else if (strcmp(argv[0], "2400") == 0)
test_bps = 2400;
else
{
fprintf(stderr, "Invalid bit rate\n");
exit(2);
}
}
inhandle = NULL;
outhandle = NULL;
filesetup = AF_NULL_FILESETUP;
if (log_audio)
{
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 (decode_test_file)
{
/* We will decode the audio from a wave file. */
if ((inhandle = afOpenFile(decode_test_file, "r", NULL)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", decode_test_file);
exit(2);
}
if ((x = afGetFrameSize(inhandle, AF_DEFAULT_TRACK, 1)) != 2.0f)
{
printf(" Unexpected frame size in speech file '%s' (%f)\n", decode_test_file, x);
exit(2);
}
if ((x = afGetRate(inhandle, AF_DEFAULT_TRACK)) != (float) SAMPLE_RATE)
{
printf(" Unexpected sample rate in speech file '%s' (%f)\n", decode_test_file, x);
exit(2);
}
if ((x = afGetChannels(inhandle, AF_DEFAULT_TRACK)) != 1.0f)
{
printf(" Unexpected number of channels in speech file '%s' (%f)\n", decode_test_file, x);
exit(2);
}
}
else
{
/* We will generate V.27ter audio, and add some noise to it. */
v27ter_tx_init(&tx, test_bps, tep, v27tergetbit, NULL);
v27ter_tx_power(&tx, signal_level);
v27ter_tx_set_modem_status_handler(&tx, v27ter_tx_status, (void *) &tx);
/* Move the carrier off a bit */
tx.carrier_phase_rate = dds_phase_ratef(1810.0f);
bert_init(&bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&bert, 10000, reporter, NULL);
if ((line_model = one_way_line_model_init(line_model_no, (float) noise_level, channel_codec, rbs_pattern)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
}
v27ter_rx_init(&rx, test_bps, v27terputbit, NULL);
v27ter_rx_set_modem_status_handler(&rx, v27ter_rx_status, (void *) &rx);
v27ter_rx_set_qam_report_handler(&rx, qam_report, (void *) &rx);
span_log_set_level(&rx.logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);
span_log_set_tag(&rx.logging, "V.27ter-rx");
#if defined(ENABLE_GUI)
if (use_gui)
{
qam_monitor = qam_monitor_init(2.0f, NULL);
if (!decode_test_file)
{
start_line_model_monitor(129);
line_model_monitor_line_model_update(line_model->near_filter, line_model->near_filter_len);
}
}
#endif
memset(&latest_results, 0, sizeof(latest_results));
for (block = 0; ; block++)
{
if (decode_test_file)
{
samples = afReadFrames(inhandle,
AF_DEFAULT_TRACK,
amp,
BLOCK_LEN);
#if defined(ENABLE_GUI)
if (use_gui)
qam_monitor_update_audio_level(qam_monitor, amp, samples);
#endif
if (samples == 0)
break;
}
else
{
samples = v27ter_tx(&tx, gen_amp, BLOCK_LEN);
#if defined(ENABLE_GUI)
if (use_gui)
qam_monitor_update_audio_level(qam_monitor, gen_amp, samples);
#endif
if (samples == 0)
{
printf("Restarting on zero output\n");
/* Push a little silence through, to ensure all the data bits get out of the buffers */
memset(amp, 0, BLOCK_LEN*sizeof(int16_t));
v27ter_rx(&rx, amp, BLOCK_LEN);
v27ter_rx(&rx, amp, BLOCK_LEN);
v27ter_rx(&rx, amp, BLOCK_LEN);
/* Note that we might get a few bad bits as the carrier shuts down. */
bert_result(&bert, &bert_results);
fprintf(stderr, "Final result %ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
fprintf(stderr, "Last report %ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, latest_results.total_bits, latest_results.bad_bits, latest_results.resyncs);
/* See if bit errors are appearing yet. Also check we are getting enough bits out of the receiver. The last regular report
should be error free, though the final report will generally contain bits errors as the carrier was dying. The total
number of bits out of the receiver should be at least the number we sent. Also, since BERT sync should have occurred
rapidly at the start of transmission, the last report should have occurred at not much less than the total number of
bits we sent. */
if (bert_results.total_bits < bits_per_test
||
latest_results.total_bits < bits_per_test - 100
||
latest_results.bad_bits != 0)
{
break;
}
memset(&latest_results, 0, sizeof(latest_results));
signal_level--;
v27ter_tx_restart(&tx, test_bps, tep);
v27ter_tx_power(&tx, signal_level);
v27ter_rx_restart(&rx, test_bps, FALSE);
bert_init(&bert, bits_per_test, BERT_PATTERN_ITU_O152_11, test_bps, 20);
bert_set_report(&bert, 10000, reporter, NULL);
one_way_line_model_release(line_model);
if ((line_model = one_way_line_model_init(line_model_no, (float) noise_level, channel_codec, 0)) == NULL)
{
fprintf(stderr, " Failed to create line model\n");
exit(2);
}
}
if (log_audio)
{
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
gen_amp,
samples);
if (outframes != samples)
{
fprintf(stderr, " Error writing wave file\n");
exit(2);
}
}
one_way_line_model(line_model, amp, gen_amp, samples);
}
#if defined(ENABLE_GUI)
if (use_gui && !decode_test_file)
line_model_monitor_line_spectrum_update(amp, samples);
#endif
v27ter_rx(&rx, amp, samples);
if (decode_test_file == NULL && block%500 == 0)
printf("Noise level is %d\n", noise_level);
}
if (!decode_test_file)
{
bert_result(&bert, &bert_results);
fprintf(stderr, "At completion:\n");
fprintf(stderr, "Final result %ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
fprintf(stderr, "Last report %ddBm0, %d bits, %d bad bits, %d resyncs\n", signal_level, latest_results.total_bits, latest_results.bad_bits, latest_results.resyncs);
one_way_line_model_release(line_model);
if (signal_level > -43)
{
printf("Tests failed.\n");
exit(2);
}
printf("Tests passed.\n");
}
#if defined(ENABLE_GUI)
if (use_gui)
qam_wait_to_end(qam_monitor);
#endif
if (log_audio)
{
if (afCloseFile(outhandle))
{
fprintf(stderr, " Cannot close wave file '%s'\n", OUT_FILE_NAME);
exit(2);
}
afFreeFileSetup(filesetup);
}
return 0;
}
int main (int argc, char **argv)
{
AFfilesetup setup;
if ((setup = afNewFileSetup()) == AF_NULL_FILESETUP)
{
fprintf(stderr, "Could not allocate file setup.\n");
exit(EXIT_FAILURE);
}
afInitFileFormat(setup, AF_FILE_IRCAM);
afInitChannels(setup, AF_DEFAULT_TRACK, 1);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_FLOAT, 32);
char *testFileName;
if (!createTemporaryFile("floatto24", &testFileName))
{
fprintf(stderr, "Could not create temporary file.\n");
exit(EXIT_FAILURE);
}
AFfilehandle file = afOpenFile(testFileName, "w", setup);
if (file == AF_NULL_FILEHANDLE)
{
printf("could not open file for writing\n");
exit(EXIT_FAILURE);
}
afFreeFileSetup(setup);
AFframecount framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, samples,
frameCount);
if (framesWritten != frameCount)
{
fprintf(stderr, "Wrong number of frames read.\n");
exit(EXIT_FAILURE);
}
if (afCloseFile(file) != 0)
{
fprintf(stderr, "Closing file returned non-zero status.\n");
exit(EXIT_FAILURE);
}
file = afOpenFile(testFileName, "r", AF_NULL_FILESETUP);
if (file == AF_NULL_FILEHANDLE)
{
fprintf(stderr, "Could not open file for writing.\n");
exit(EXIT_FAILURE);
}
if (afSetVirtualSampleFormat(file, AF_DEFAULT_TRACK,
AF_SAMPFMT_TWOSCOMP, 24) != 0)
{
fprintf(stderr, "afSetVirtualSampleFormat returned non-zero status.\n");
exit(EXIT_FAILURE);
}
int readSamples[frameCount];
for (int i=0; i<frameCount; i++)
readSamples[i] = -1000 - i;
AFframecount framesRead = afReadFrames(file, AF_DEFAULT_TRACK, readSamples,
frameCount);
if (framesRead != frameCount)
{
fprintf(stderr, "Wrong number of frames read.\n");
exit(EXIT_FAILURE);
}
for (int i=0; i<framesRead; i++)
{
#ifdef DEBUG
printf("[%d] = %d\n", i, readSamples[i]);
#endif
if (readSamples[i] == -1000 - i)
{
fprintf(stderr, "Data in destination array untouched.\n");
exit(EXIT_FAILURE);
}
/*
Ensure that the high-order 8 bits represent
sign extension: only 0x00 (+) or 0xff (-) is
valid.
*/
if ((readSamples[i] & 0xff000000) != 0x000000 &&
(readSamples[i] & 0xff000000) != 0xff000000)
{
fprintf(stderr, "Data is not within range of "
"{-2^23, ..., 2^23-1}.\n");
exit(EXIT_FAILURE);
}
if (readSamples[i] != referenceConvertedSamples[i])
{
fprintf(stderr, "Data doesn't match reference data.\n");
exit(EXIT_FAILURE);
}
}
if (afCloseFile(file) != 0)
{
fprintf(stderr, "Closing file returned non-zero status.\n");
exit(EXIT_FAILURE);
}
unlink(testFileName);
free(testFileName);
exit(EXIT_SUCCESS);
}
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 dynamic_buffer_tests(void)
{
playout_state_t *s;
playout_frame_t frame;
playout_frame_t *p;
plc_state_t plc;
time_scale_state_t ts;
int16_t *amp;
int16_t fill[BLOCK_LEN];
int16_t buf[20*BLOCK_LEN];
int16_t out[10*BLOCK_LEN];
timestamp_t time_stamp;
timestamp_t next_actual_receive;
timestamp_t next_scheduled_receive;
int near_far_time_offset;
int rng;
int i;
int j;
int ret;
int len;
int inframes;
int outframes;
AFfilehandle inhandle;
AFfilehandle outhandle;
AFfilesetup filesetup;
filesetup = afNewFileSetup();
if (filesetup == 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, 2);
inhandle = afOpenFile(INPUT_FILE_NAME, "r", NULL);
if (inhandle == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Failed to open wave file '%s'\n", INPUT_FILE_NAME);
exit(2);
}
outhandle = afOpenFile(OUTPUT_FILE_NAME, "w", filesetup);
if (outhandle == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Failed to create wave file '%s'\n", OUTPUT_FILE_NAME);
exit(2);
}
near_far_time_offset = 54321;
time_stamp = 12345;
next_actual_receive = time_stamp + near_far_time_offset;
next_scheduled_receive = 0;
for (i = 0; i < BLOCK_LEN; i++)
fill[i] = 32767;
if ((s = playout_new(2*BLOCK_LEN, 15*BLOCK_LEN)) == NULL)
return;
plc_init(&plc);
time_scale_init(&ts, 1.0);
for (i = 0; i < 1000000; i++)
{
if (i >= next_actual_receive)
{
amp = malloc(BLOCK_LEN*sizeof(int16_t));
inframes = afReadFrames(inhandle,
AF_DEFAULT_TRACK,
amp,
BLOCK_LEN);
if (inframes < BLOCK_LEN)
break;
ret = playout_put(s,
amp,
PLAYOUT_TYPE_SPEECH,
inframes,
time_stamp,
next_actual_receive);
#if 0
switch (ret)
{
case PLAYOUT_OK:
printf("<< Record\n");
break;
case PLAYOUT_ERROR:
printf("<< Error\n");
break;
default:
printf("<< Eh?\n");
break;
}
#endif
rng = rand() & 0xFF;
if (i < 100000)
rng = (rng*rng) >> 7;
else if (i < 200000)
rng = (rng*rng) >> 6;
else if (i < 300000)
static enum audiotap_status audiofile_set_buffer(void *priv, int32_t *buffer, uint32_t bufsize, uint32_t *numframes) {
*numframes=afReadFrames((AFfilehandle)priv, AF_DEFAULT_TRACK, buffer, bufsize);
return *numframes == -1 ? AUDIOTAP_LIBRARY_ERROR : AUDIOTAP_OK;
}
int main(int argc, char *argv[])
{
fsk_rx_state_t *fsk;
v17_rx_state_t *v17;
v29_rx_state_t *v29;
v27ter_rx_state_t *v27ter;
int16_t amp[SAMPLES_PER_CHUNK];
AFfilehandle inhandle;
int len;
const char *filename;
float x;
logging_state_t *logging;
filename = "fax_samp.wav";
if (argc > 1)
filename = argv[1];
if ((inhandle = afOpenFile(filename, "r", NULL)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", filename);
exit(2);
}
if ((x = afGetFrameSize(inhandle, AF_DEFAULT_TRACK, 1)) != 2.0)
{
printf(" Unexpected frame size in speech file '%s' (%f)\n", filename, x);
exit(2);
}
if ((x = afGetRate(inhandle, AF_DEFAULT_TRACK)) != (float) SAMPLE_RATE)
{
printf(" Unexpected sample rate in speech file '%s' (%f)\n", filename, x);
exit(2);
}
if ((x = afGetChannels(inhandle, AF_DEFAULT_TRACK)) != 1.0)
{
printf(" Unexpected number of channels in speech file '%s' (%f)\n", filename, x);
exit(2);
}
memset(&t30_dummy, 0, sizeof(t30_dummy));
span_log_init(&t30_dummy.logging, SPAN_LOG_FLOW, NULL);
span_log_set_protocol(&t30_dummy.logging, "T.30");
hdlc_rx_init(&hdlcrx, FALSE, TRUE, 5, hdlc_accept, NULL);
fsk = fsk_rx_init(NULL, &preset_fsk_specs[FSK_V21CH2], TRUE, v21_put_bit, NULL);
v17 = v17_rx_init(NULL, 14400, v17_put_bit, NULL);
v29 = v29_rx_init(NULL, 9600, v29_put_bit, NULL);
//v29 = v29_rx_init(NULL, 7200, v29_put_bit, NULL);
v27ter = v27ter_rx_init(NULL, 4800, v27ter_put_bit, NULL);
fsk_rx_signal_cutoff(fsk, -45.5);
v17_rx_signal_cutoff(v17, -45.5);
v29_rx_signal_cutoff(v29, -45.5);
v27ter_rx_signal_cutoff(v27ter, -40.0);
#if 1
logging = v17_rx_get_logging_state(v17);
span_log_init(logging, SPAN_LOG_FLOW, NULL);
span_log_set_protocol(logging, "V.17");
span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_FLOW);
logging = v29_rx_get_logging_state(v29);
span_log_init(logging, SPAN_LOG_FLOW, NULL);
span_log_set_protocol(logging, "V.29");
span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_FLOW);
logging = v27ter_rx_get_logging_state(v27ter);
span_log_init(logging, SPAN_LOG_FLOW, NULL);
span_log_set_protocol(logging, "V.27ter");
span_log_set_level(logging, SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_SHOW_TAG | SPAN_LOG_FLOW);
#endif
if (t4_rx_init(&t4_state, "fax_decode.tif", T4_COMPRESSION_ITU_T4_2D) == NULL)
{
fprintf(stderr, "Failed to init\n");
exit(0);
}
for (;;)
{
len = afReadFrames(inhandle, AF_DEFAULT_TRACK, amp, SAMPLES_PER_CHUNK);
if (len < SAMPLES_PER_CHUNK)
break;
fsk_rx(fsk, amp, len);
v17_rx(v17, amp, len);
v29_rx(v29, amp, len);
//v27ter_rx(v27ter, amp, len);
}
t4_rx_release(&t4_state);
if (afCloseFile(inhandle) != 0)
{
fprintf(stderr, " Cannot close wave file '%s'\n", filename);
exit(2);
}
return 0;
}
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);
}
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);
}
int main (int argc, char **argv)
{
AFfilesetup setup;
AFfilehandle file;
int16_t samples[SAMPLE_COUNT] = {-1,3,9,2,-5,4,8,-3,6,21,11,-2};
int output = 0;
setup = afNewFileSetup();
afInitFileFormat(setup, AF_FILE_RAWDATA);
afInitSampleFormat(setup, AF_DEFAULT_TRACK, AF_SAMPFMT_TWOSCOMP, 16);
afInitChannels(setup, AF_DEFAULT_TRACK, 2);
afInitRate(setup, AF_DEFAULT_TRACK, 44100);
#ifdef WORDS_BIGENDIAN
afInitByteOrder(setup, AF_DEFAULT_TRACK, AF_BYTEORDER_BIGENDIAN);
#else
afInitByteOrder(setup, AF_DEFAULT_TRACK, AF_BYTEORDER_LITTLEENDIAN);
#endif
if (argc > 1 && !strcmp(argv[1], "out"))
output = 1;
if (output)
{
AFframecount framesWritten;
file = afOpenFD(1, "w", setup);
afFreeFileSetup(setup);
framesWritten = afWriteFrames(file, AF_DEFAULT_TRACK, samples,
FRAME_COUNT);
ensure(framesWritten == FRAME_COUNT,
"incorrect number of frames written");
fprintf(stderr, "pipe write passed\n");
}
else
{
AFframecount framesRead;
int16_t samplesRead[SAMPLE_COUNT];
file = afOpenFD(0, "r", setup);
afFreeFileSetup(setup);
framesRead = afReadFrames(file, AF_DEFAULT_TRACK, samplesRead,
FRAME_COUNT);
ensure(framesRead == FRAME_COUNT,
"incorrect number of frames read");
ensure(memcmp(samplesRead, samples,
SAMPLE_COUNT * sizeof (int16_t)) == 0,
"samples read do not match samples written");
fprintf(stderr, "pipe read passed\n");
}
afCloseFile(file);
exit(EXIT_SUCCESS);
}
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;
}
main (int argc, char **argv)
{
AFfilehandle file;
AFframecount count, frameCount;
int channelCount, sampleFormat, sampleWidth;
float frameSize;
void *buffer;
double sampleRate;
ALport outport;
ALconfig outportconfig;
if (argc < 2)
usage();
file = afOpenFile(argv[1], "r", NULL);
if (file == AF_NULL_FILEHANDLE)
{
fprintf(stderr, "Could not open file %s.\n", argv[1]);
exit(EXIT_FAILURE);
}
frameCount = afGetFrameCount(file, AF_DEFAULT_TRACK);
frameSize = afGetVirtualFrameSize(file, AF_DEFAULT_TRACK, 1);
channelCount = afGetVirtualChannels(file, AF_DEFAULT_TRACK);
sampleRate = afGetRate(file, AF_DEFAULT_TRACK);
afGetVirtualSampleFormat(file, AF_DEFAULT_TRACK, &sampleFormat,
&sampleWidth);
if (sampleFormat == AF_SAMPFMT_UNSIGNED)
{
afSetVirtualSampleFormat(file, AF_DEFAULT_TRACK,
AF_SAMPFMT_TWOSCOMP, sampleWidth);
}
printf("frame count: %lld\n", frameCount);
printf("frame size: %d bytes\n", (int) frameSize);
printf("channel count: %d\n", channelCount);
printf("sample rate: %.2f Hz\n", sampleRate);
buffer = malloc(BUFFERED_FRAME_COUNT * frameSize);
outportconfig = alNewConfig();
setwidth(outportconfig, sampleWidth);
setsampleformat(outportconfig, sampleFormat);
alSetChannels(outportconfig, channelCount);
count = afReadFrames(file, AF_DEFAULT_TRACK, buffer, BUFFERED_FRAME_COUNT);
outport = alOpenPort("irixread", "w", outportconfig);
setrate(outport, sampleRate);
do
{
printf("count = %lld\n", count);
alWriteFrames(outport, buffer, count);
count = afReadFrames(file, AF_DEFAULT_TRACK, buffer,
BUFFERED_FRAME_COUNT);
} while (count > 0);
waitport(outport);
alClosePort(outport);
alFreeConfig(outportconfig);
afCloseFile(file);
}
int main(int argc, char *argv[])
{
AFfilehandle inhandle;
AFfilehandle outhandle;
int outframes;
int opt;
int samples;
int len2;
int len3;
int basic_tests;
int law;
int encode;
int decode;
int file;
const char *in_file;
const char *out_file;
g711_state_t *enc_state;
g711_state_t *dec_state;
int16_t indata[BLOCK_LEN];
int16_t outdata[BLOCK_LEN];
uint8_t g711data[BLOCK_LEN];
basic_tests = TRUE;
law = G711_ALAW;
encode = FALSE;
decode = FALSE;
in_file = NULL;
out_file = NULL;
while ((opt = getopt(argc, argv, "ad:e:l:u")) != -1)
{
switch (opt)
{
case 'a':
law = G711_ALAW;
basic_tests = FALSE;
break;
case 'd':
in_file = optarg;
basic_tests = FALSE;
decode = TRUE;
break;
case 'e':
in_file = optarg;
basic_tests = FALSE;
encode = TRUE;
break;
case 'l':
out_file = optarg;
break;
case 'u':
law = G711_ULAW;
basic_tests = FALSE;
break;
default:
//usage();
exit(2);
}
}
if (basic_tests)
{
compliance_tests(TRUE);
}
else
{
if (!decode && !encode)
{
decode =
encode = TRUE;
}
if (in_file == NULL)
{
in_file = (encode) ? IN_FILE_NAME : ENCODED_FILE_NAME;
}
if (out_file == NULL)
{
out_file = (decode) ? OUT_FILE_NAME : ENCODED_FILE_NAME;
}
inhandle = AF_NULL_FILEHANDLE;
outhandle = AF_NULL_FILEHANDLE;
file = -1;
enc_state = NULL;
dec_state = NULL;
if (encode)
{
if ((inhandle = afOpenFile_telephony_read(in_file, 1)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot open wave file '%s'\n", in_file);
exit(2);
}
enc_state = g711_init(NULL, law);
}
else
{
if ((file = open(in_file, O_RDONLY)) < 0)
{
fprintf(stderr, " Failed to open '%s'\n", in_file);
exit(2);
}
}
if (decode)
{
if ((outhandle = afOpenFile_telephony_write(out_file, 1)) == AF_NULL_FILEHANDLE)
{
fprintf(stderr, " Cannot create wave file '%s'\n", out_file);
exit(2);
}
dec_state = g711_init(NULL, law);
}
else
{
if ((file = open(out_file, O_WRONLY | O_CREAT | O_TRUNC, 0666)) < 0)
{
fprintf(stderr, " Failed to open '%s'\n", out_file);
exit(2);
}
}
for (;;)
{
if (encode)
{
samples = afReadFrames(inhandle,
AF_DEFAULT_TRACK,
indata,
BLOCK_LEN);
if (samples <= 0)
break;
len2 = g711_encode(enc_state, g711data, indata, samples);
}
else
{
len2 = read(file, g711data, BLOCK_LEN);
if (len2 <= 0)
break;
}
if (decode)
{
len3 = g711_decode(dec_state, outdata, g711data, len2);
outframes = afWriteFrames(outhandle,
AF_DEFAULT_TRACK,
outdata,
len3);
if (outframes != len3)
{
fprintf(stderr, " Error writing wave file\n");
exit(2);
}
}
else
{
len3 = write(file, g711data, len2);
if (len3 <= 0)
break;
}
}
if (encode)
{
if (afCloseFile(inhandle))
{
fprintf(stderr, " Cannot close wave file '%s'\n", IN_FILE_NAME);
exit(2);
}
}
else
{
close(file);
}
if (decode)
{
if (afCloseFile(outhandle))
{
fprintf(stderr, " Cannot close wave file '%s'\n", OUT_FILE_NAME);
exit(2);
}
}
else
{
close(file);
}
printf("'%s' translated to '%s' using %s.\n", in_file, out_file, (law == G711_ALAW) ? "A-law" : "u-law");
}
return 0;
}
static void
audiofile_stream_decode(struct decoder *decoder, struct input_stream *is)
{
AFvirtualfile *vf;
int fs, frame_count;
AFfilehandle af_fp;
int bits;
struct audio_format audio_format;
float total_time;
uint16_t bit_rate;
int ret, current = 0;
char chunk[CHUNK_SIZE];
enum decoder_command cmd;
if (!is->seekable) {
g_warning("not seekable");
return;
}
vf = setup_virtual_fops(is);
af_fp = afOpenVirtualFile(vf, "r", NULL);
if (af_fp == AF_NULL_FILEHANDLE) {
g_warning("failed to input stream\n");
return;
}
afGetSampleFormat(af_fp, AF_DEFAULT_TRACK, &fs, &bits);
if (!audio_valid_sample_format(bits)) {
g_debug("input file has %d bit samples, converting to 16",
bits);
bits = 16;
}
afSetVirtualSampleFormat(af_fp, AF_DEFAULT_TRACK,
AF_SAMPFMT_TWOSCOMP, bits);
afGetVirtualSampleFormat(af_fp, AF_DEFAULT_TRACK, &fs, &bits);
audio_format.bits = (uint8_t)bits;
audio_format.sample_rate =
(unsigned int)afGetRate(af_fp, AF_DEFAULT_TRACK);
audio_format.channels =
(uint8_t)afGetVirtualChannels(af_fp, AF_DEFAULT_TRACK);
if (!audio_format_valid(&audio_format)) {
g_warning("Invalid audio format: %u:%u:%u\n",
audio_format.sample_rate, audio_format.bits,
audio_format.channels);
afCloseFile(af_fp);
return;
}
frame_count = afGetFrameCount(af_fp, AF_DEFAULT_TRACK);
total_time = ((float)frame_count / (float)audio_format.sample_rate);
bit_rate = (uint16_t)(is->size * 8.0 / total_time / 1000.0 + 0.5);
fs = (int)afGetVirtualFrameSize(af_fp, AF_DEFAULT_TRACK, 1);
decoder_initialized(decoder, &audio_format, true, total_time);
do {
ret = afReadFrames(af_fp, AF_DEFAULT_TRACK, chunk,
CHUNK_SIZE / fs);
if (ret <= 0)
break;
current += ret;
cmd = decoder_data(decoder, NULL,
chunk, ret * fs,
(float)current /
(float)audio_format.sample_rate,
bit_rate, NULL);
if (cmd == DECODE_COMMAND_SEEK) {
current = decoder_seek_where(decoder) *
audio_format.sample_rate;
afSeekFrame(af_fp, AF_DEFAULT_TRACK, current);
decoder_command_finished(decoder);
cmd = DECODE_COMMAND_NONE;
}
} while (cmd == DECODE_COMMAND_NONE);
afCloseFile(af_fp);
}
void print_power (char *filename)
{
AFfilehandle file;
double *sums, *frames;
int channelCount, windowSize, frameCount;
int i, c;
struct smooth *powsmooth;
int winStart, winEnd;
int lastWindow = FALSE;
double pow, maxpow;
double level, peak, minSample = 1, maxSample = -1;
file = afOpenFile(filename, "r", NULL);
if (file == AF_NULL_FILEHANDLE)
{
fprintf(stderr, "Could not open file %s.\n", filename);
return;
}
channelCount = afGetChannels(file, AF_DEFAULT_TRACK);
windowSize = afGetRate(file, AF_DEFAULT_TRACK) / 100;
frameCount = afGetFrameCount(file, AF_DEFAULT_TRACK);
sums = calloc(channelCount, sizeof (double));
for (c=0; c<channelCount; c++)
sums[c] = 0;
frames = calloc(channelCount * windowSize, sizeof (double));
afSetVirtualSampleFormat(file, AF_DEFAULT_TRACK, AF_SAMPFMT_DOUBLE,
sizeof (double));
powsmooth = calloc(channelCount, sizeof (struct smooth));
for (c=0; c<channelCount; c++)
{
/* Use a 100-element (1 second) window. */
powsmooth[c].length = 100;
powsmooth[c].buf = calloc(powsmooth[c].length, sizeof (double));
powsmooth[c].start = 0;
powsmooth[c].n = 0;
}
winStart = 0;
winEnd = 0;
lastWindow = FALSE;
maxpow = 0;
do
{
winEnd = winStart + windowSize;
if (winEnd >= frameCount)
{
winEnd = frameCount;
lastWindow = TRUE;
}
afReadFrames(file, AF_DEFAULT_TRACK, frames, windowSize);
for (c=0; c<channelCount; c++)
{
sums[c] = 0;
for (i=0; i < winEnd - winStart; i++)
{
double sample;
sample = frames[i*channelCount + c];
sums[c] += sample*sample;
if (sample > maxSample)
maxSample = sample;
if (sample < minSample)
minSample = sample;
}
}
/* Compute power for each channel. */
for (c=0; c<channelCount; c++)
{
double pow;
int end;
pow = sums[c] / (winEnd - winStart);
end = (powsmooth[c].start + powsmooth[c].n) %
powsmooth[c].length;
powsmooth[c].buf[end] = pow;
if (powsmooth[c].n == powsmooth[c].length)
{
powsmooth[c].start = (powsmooth[c].start + 1) % powsmooth[c].length;
pow = get_smoothed_data(&powsmooth[c]);
if (pow > maxpow)
maxpow = pow;
}
else
{
powsmooth[c].n++;
}
}
winStart += windowSize;
} while (!lastWindow);
for (c = 0; c < channelCount; c++)
{
pow = get_smoothed_data(&powsmooth[c]);
if (pow > maxpow)
maxpow = pow;
}
free(sums);
free(frames);
for (c=0; c<channelCount; c++)
free(powsmooth[c].buf);
free(powsmooth);
level = sqrt(maxpow);
afCloseFile(file);
printf("file: %s\n", filename);
printf("level (dB): %f\n", 20 * log10(level));
printf("peak-: %f\n", minSample);
printf("peak+: %f\n", maxSample);
peak = abs(minSample);
if (peak < abs(maxSample))
peak = abs(maxSample);
printf("peak (dB): %f\n", 20 * log10(peak));
}
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;
}
main()
{
LS_DATA ls_data;
FILE *fp;
double gains[MAX_CHANNELS];
int azimuth=-10;
int elevation=14;
double *gainptr, gain;
short *inptr,*outptr;
short out[BUFFER_LENGTH][MAX_CHANNELS];
ALconfig c;
AFfilehandle fh;
ALport p;
short *in;
long frames;
int i,j,k;
int numchannels = 8; /* change this according your output device*/
int ls_set_dim = 3;
int ls_num = 8;
int ls_dirs[MAX_FIELD_AM]={-30,0, 30,0, -45,45, 45,45, -90,0,
90,0, 180,0, 180,45};
/* change these according to your loudspeaker positioning*/
/* defining loudspeaker data */
define_loudspeakers(&ls_data, ls_set_dim, ls_num, ls_dirs);
/* ls_data is a struct containing matrices etc
ls_set_dim is 2 if loudspeakers are on a (horizontal) plane
ls_set_dim is 3 if also elevated or descended loudpeakers exist
ls_num is the number of loudspeakers
ls_dirs is an array containing the angular directions of loudsp*/
/* gain factors for virtual source in direction
(int azimuth, int elevation) */
vbap(gains, &ls_data, azimuth, elevation);
/* panning monophonic stream float *in
to multiple outputs float *out[]
with gain factors float *gains */
/* input audio*/
if((fh=afOpenFile("myaiff.aiff","r",0))==NULL){
fprintf(stderr, "Could not open file myaiff.aiff\n");
exit(-1);
}
frames=AFgetframecnt(fh,AF_DEFAULT_TRACK);
if(afGetChannels(fh, AF_DEFAULT_TRACK) != 1){
fprintf(stderr, "Supports only mono aiff-files\n");
exit(-1);
}
in= malloc(frames*sizeof(short)*2);
afReadFrames(fh,AF_DEFAULT_TRACK,in,frames);
/*opening the audio port*/
c = alNewConfig();
if (!c) {
printf("Couldn't create ALconfig:%s\n", alGetErrorString(oserror()));
exit(-1);
}
alSetChannels(c,numchannels);
ALsetqueuesize(c,BUFFER_LENGTH);
p = alOpenPort("alVBAP example","w",c);
if (!p) {
printf("port open failed:%s\n", alGetErrorString(oserror()));
exit(-1);
}
fprintf(stderr,"\nPanning audio");
for(j=0;j<(frames/BUFFER_LENGTH);j++){
inptr = &(in[j*BUFFER_LENGTH]); /* audio to be panned */
outptr= out[0];
for (i=0; i<BUFFER_LENGTH; i++){ /* panning */
gainptr=gains;
for (k=0; k<numchannels; k++){
*outptr++ = (short) ((double) *inptr * *gainptr++);
}
inptr++;
}
alWriteFrames(p, out, BUFFER_LENGTH); /* write frames */
fprintf(stderr,".");
}
/*write rest samples out*/
inptr = &(in[j*BUFFER_LENGTH]); /* partial buffer */
outptr= out[0];
for (i=0; i<(frames-BUFFER_LENGTH*j); i++){ /* panning */
gainptr=gains;
for (k=0; k<numchannels; k++){
*outptr++ = (short) ((double) *inptr * *gainptr++);
}
inptr++;
}
for (;i<BUFFER_LENGTH; i++){ /* zeros */
for (k=0; k<numchannels; k++){
*outptr++ = 0;
}
}
alWriteFrames(p, out, BUFFER_LENGTH); /* write frames */
fprintf(stderr,".");
printf("\n\nDone!\n\n");
}
