int main(void) {
int fd = open_device();
init_device(fd);
read_frames(fd);
close_device(fd);
atomic_puts("EXIT-SUCCESS");
return 0;
}
status_t
read_cdda_data(int fd, off_t endFrame, off_t offset, void *data, size_t length,
off_t bufferOffset, void *buffer, size_t bufferSize)
{
if (bufferOffset >= 0 && bufferOffset <= offset + length
&& bufferOffset + bufferSize > offset) {
if (offset >= bufferOffset) {
// buffer reaches into the beginning of the request
off_t dataOffset = offset - bufferOffset;
size_t bytes = min_c(bufferSize - dataOffset, length);
if (user_memcpy(data, (uint8 *)buffer + dataOffset, bytes) < B_OK)
return B_BAD_ADDRESS;
data = (void *)((uint8 *)data + bytes);
length -= bytes;
offset += bytes;
} else if (offset < bufferOffset
&& offset + length < bufferOffset + bufferSize) {
// buffer overlaps at the end of the request
off_t dataOffset = bufferOffset - offset;
size_t bytes = length - dataOffset;
if (user_memcpy((uint8 *)data + dataOffset, buffer, bytes) < B_OK)
return B_BAD_ADDRESS;
length -= bytes;
}
// we don't handle the case where we would need to split the request
}
while (length > 0) {
off_t frame = offset / kFrameSize;
uint32 count = bufferSize / kFrameSize;
if (frame + count > endFrame)
count = endFrame - frame;
status_t status = read_frames(fd, frame, (uint8 *)buffer, count);
if (status < B_OK)
return status;
off_t dataOffset = offset % kFrameSize;
size_t bytes = bufferSize - dataOffset;
if (bytes > length)
bytes = length;
if (user_memcpy(data, (uint8 *)buffer + dataOffset, bytes) < B_OK)
return B_BAD_ADDRESS;
data = (void *)((uint8 *)data + bytes);
length -= bytes;
offset += bytes;
}
return B_OK;
}
int main(void)
{
void *frames;
size_t size;
size = read_frames(&frames);
if (size == 0) {
return EXIT_FAILURE;
}
if (write_file(frames, size) < 0) {
free(frames);
return EXIT_FAILURE;
}
free(frames);
return EXIT_SUCCESS;
}
void Processor::process(){
std::cout << "Processing file." << std::endl;
SDL_Renderer* renderer = yield_renderer();
size_t frame_idx = 0;
sf_count_t readCount = 0;
int i = 0;
float centroid = 0;
float flow = 0;
float to_wait = FFT_SIZE / float(m_sampleRate);
bool must_break = false;
float* previous_magnitudes = new float[FFT_SIZE];
for (int j = 0; j < FFT_SIZE; ++j) {
previous_magnitudes[j] = 0;
}
while((readCount = read_frames(frame_idx)) > 0){
to_mono(fft_in, readCount);
frame_idx+=readCount;
fftw_execute(trans);
ProcessingTools::plotData(renderer, fft_in, FFT_SIZE);
SDL_Delay(500);
if( i < NUMBER_OF_WINDOWS ){
fftw_execute(trans);
for(int j=0; j < m_bufsize/m_channelCount; j++){
if( DEBUG_ENABLED ){
std::cout << fft_in[j][0];
}
}
float* magnitudes = new float[FFT_SIZE];
float* lolz = ProcessingTools::get_magnitude(magnitudes, fft_out, FFT_SIZE);
float result_centroids = ProcessingTools::compute_centroid(magnitudes, FFT_SIZE);
centroid += result_centroids;
float result_flow = ProcessingTools::compute_flow(magnitudes, previous_magnitudes, FFT_SIZE);
flow += result_flow;
if(DEBUG_ENABLED){
std::cout << "Centroid: ";
std::cout << result_centroids << std::endl;
std::cout << "Flow: ";
std::cout << result_flow << std::endl;
}
for( int j = 0; j < FFT_SIZE; ++j){
previous_magnitudes[j] = magnitudes[j];
}
i++;
}else{
break;
}
}
std::cout << "Centroid: ";
std::cout << (centroid/NUMBER_OF_WINDOWS) << std::endl;
std::cout << "Flow: ";
std::cout << (flow/NUMBER_OF_WINDOWS) << std::endl;
std::cout << "Processing file done." << std::endl;
SDL_DestroyRenderer(renderer);
SDL_Quit();
}
