static int audiofile_seek_to_beginning(struct audiotap *audiotap) { audiotap->has_flushed = 0; audiotap->accumulated_samples = 0; audiotap->bufroom = 0; tapenc_flush(audiotap->tapenc); return afSeekFrame((AFfilehandle)audiotap->priv, AF_DEFAULT_TRACK, 0) == 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); }
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); }
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); }
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); }
static void audiofile_stream_decode(struct decoder *decoder, struct input_stream *is) { GError *error = NULL; AFvirtualfile *vf; int fs, frame_count; AFfilehandle af_fp; struct audio_format audio_format; float total_time; uint16_t bit_rate; int ret; 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; } if (!audio_format_init_checked(&audio_format, afGetRate(af_fp, AF_DEFAULT_TRACK), audiofile_setup_sample_format(af_fp), afGetVirtualChannels(af_fp, AF_DEFAULT_TRACK), &error)) { g_warning("%s", error->message); g_error_free(error); 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; cmd = decoder_data(decoder, NULL, chunk, ret * fs, bit_rate); if (cmd == DECODE_COMMAND_SEEK) { AFframecount frame = decoder_seek_where(decoder) * audio_format.sample_rate; afSeekFrame(af_fp, AF_DEFAULT_TRACK, frame); decoder_command_finished(decoder); cmd = DECODE_COMMAND_NONE; } } while (cmd == DECODE_COMMAND_NONE); afCloseFile(af_fp); }
AFfileoffset afTellFrame (AFfilehandle file, int trackid) { return afSeekFrame(file, trackid, -1); }