/*************************************************************************************** * Pushbutton - Interrupt Service Routine * * This ISR checks which KEY has been pressed. If KEY1, then it enables audio-in * interrupts (recording). If KEY2, it enables audio-out interrupts (playback). ****************************************************************************************/ void pushbutton_ISR(struct alt_up_dev *up_dev, unsigned int id) { alt_up_audio_dev *audio_dev; audio_dev = up_dev->audio_dev; int KEY_value; /* read the pushbutton interrupt register */ KEY_value = alt_up_parallel_port_read_edge_capture (up_dev->KEY_dev); alt_up_parallel_port_clear_edge_capture (up_dev->KEY_dev); // clear the interrupt if (KEY_value == 0x2) // check KEY1 { // reset the buffer index for recording buf_index_record = 0; // clear audio FIFOs alt_up_audio_reset_audio_core (audio_dev); // enable audio-in interrupts alt_up_audio_enable_read_interrupt (audio_dev); } else if (KEY_value == 0x4) // check KEY2 { // reset counter to start playback buf_index_play = 0; // clear audio FIFOs alt_up_audio_reset_audio_core (audio_dev); // enable audio-out interrupts alt_up_audio_enable_write_interrupt (audio_dev); } return; }
void disableSound() { printf("disable\n"); sound_data_counter = 0; alt_up_audio_disable_write_interrupt(audio_dev); alt_up_audio_reset_audio_core(audio_dev); }
/* The audio task is responsible for continuously playing music * off the SD card. */ void audio_task(void *pdata) { int err = 0; err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_ACTIVE_CTRL, 0x00); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_LEFT_LINE_IN, 0x97); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_RIGHT_LINE_IN, 0x97); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_LEFT_HEADPHONE_OUT, 0x79); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_RIGHT_HEADPHONE_OUT, 0x79); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_ANALOG_AUDIO_PATH_CTRL, 0x12); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_DIGITAL_AUDIO_PATH_CTRL, 0x05); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_POWER_DOWN_CTRL, 0x07); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_AUDIO_DIGITAL_INTERFACE, 0x42); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_SAMPLING_CTRL, 0x22); err += alt_up_av_config_write_audio_cfg_register(av_dev, AUDIO_REG_ACTIVE_CTRL, 0x01); err += audio_set_headphone_volume(av_dev, DEFAULT_VOLUME); if(err < 0) printf("Audio Configuration Failed\n"); alt_up_audio_reset_audio_core(audio_dev); alt_up_audio_disable_read_interrupt(audio_dev); alt_up_audio_disable_write_interrupt(audio_dev); char fileName[10] = {"class.wav\0"}; if (file_fopen(&readFile, &efsl.myFs, fileName, 'r') != 0) printf("Error:\tCould not open file\n"); int readSize = 0; euint32 currentSize = 44; euint8 buf[AUDIO_BUF_SIZE]; int i; /* The task is suspended so that it can be played by another task. */ OSTaskSuspend(AUDIO_TASK_PRIORITY); while(1) { if (currentSize < readFile.FileSize) { int fifospace = alt_up_audio_write_fifo_space(audio_dev, ALT_UP_AUDIO_LEFT); if (fifospace > WORD_COUNT) { readSize = file_fread(&readFile, currentSize, AUDIO_BUF_SIZE, buf); currentSize += readSize; i = 0; while(i < AUDIO_BUF_SIZE) { IOWR_ALT_UP_AUDIO_LEFTDATA(audio_dev->base, (buf[i+1]<<8)|buf[i]); IOWR_ALT_UP_AUDIO_RIGHTDATA(audio_dev->base, (buf[i+3]<<8)|buf[i+2]); i+=4; } } } else { currentSize = 44; } } file_fclose(&readFile); }
void game_reset(master* m) { alt_up_audio_disable_write_interrupt(m->ab->audio_dev); IOWR_16DIRECT(TIMER_0_BASE, 4, 1 << 3); IOWR_16DIRECT(TIMER_1_BASE, 4, 1 << 3); IOWR_16DIRECT(TIMER_2_BASE, 4, 1 << 3); sd_fclose(m->ab->wav); reset_audio_buffer(m->ab); alt_up_audio_reset_audio_core(m->ab->audio_dev); }
void av_config_setup(){ printf("Configuring audio and video.\n"); alt_up_av_config_dev * av_config = alt_up_av_config_open_dev("/dev/audio_and_video_config_0"); while (!alt_up_av_config_read_ready(av_config)); printf("Opening audio device.\n"); audio = alt_up_audio_open_dev("/dev/audio_0"); alt_up_audio_reset_audio_core(audio); }
//Initializes audio & video core, will not return until succuessful void av_config_setup() { bool once = true; alt_up_av_config_dev * av_config = alt_up_av_config_open_dev(AV_CONFIG); while(!alt_up_av_config_read_ready(av_config)) { if(once) { printf("Error, audio not configured.\n"); once = false; } } audio = alt_up_audio_open_dev(AUDIO_DEV); alt_up_audio_reset_audio_core(audio); }
int initAudioCore(alt_up_audio_dev* audio) { alt_up_audio_reset_audio_core(audio); if (audio == NULL) { return AUDIO_ERROR; } alt_up_audio_enable_write_interrupt(audio); return 0; }
/** * Initializes the AudioController */ struct AudioController* initAudioController() { av_config_setup(); struct AudioController* this = (struct AudioController*)malloc(sizeof(struct AudioController)); this->buffer_length = 0; this->num_sounds = 0; this->audio = alt_up_audio_open_dev(AUDIO_NAME); this->clear_required = false; this->start_dirty_index = 0; this->end_dirty_index = 0; this->buffer = NULL; // alt_irq_register(AUDIO_IRQ, this, (void*) audio_ISR); // alt_irq_enable(AUDIO_IRQ); alt_up_audio_reset_audio_core(this->audio); return this; }
void play_wav (unsigned int **arr) { alt_up_audio_reset_audio_core(audio); unsigned int * input; int k = 0; input = arr[k]; while (1) { if (alt_up_audio_write_interrupt_pending(audio) == 1) { alt_up_audio_write_fifo(audio, input, 100, ALT_UP_AUDIO_LEFT); alt_up_audio_write_fifo(audio, input, 100, ALT_UP_AUDIO_RIGHT); k++; input = arr[k]; } if (k >= 4377) break; } }
//initializes audio buffer int initAudio(char* fname) { alt_up_sd_card_dev *device_reference = NULL; device_reference = alt_up_sd_card_open_dev(SD_CARD_NAME); open_sd(); av_config_setup(); init_audio_buff(ab); ab->audio = alt_up_audio_open_dev(AUDIO_0_NAME); alt_up_audio_reset_audio_core(ab->audio); file_handle = alt_up_sd_card_fopen(fname, 0); offset(file_handle, ab); fill_buff(file_handle, ab); return file_handle; }
void resetAudio(void) { alt_up_audio_reset_audio_core(audio); }
void init_wav(unsigned int *arr[]) { printf("Initializing wav file\n"); int i,j,k; int size_of_wav = 0; int location = 0; unsigned int buffer[100] = {0}; unsigned int * soundbuf; soundbuf = (unsigned int*) malloc(sizeof(char) * size_of_wav); audio = alt_up_audio_open_dev(AUDIO_DEV); alt_up_audio_reset_audio_core(audio); //alt_up_audio_enable_write_interrupt(audio); /* sound_file = alt_up_sd_card_fopen("WAV2.WAV", false); //printf("Soundfile: %d\n", sound_file); if (sound_file != -1) { printf("File opened.\n"); while(alt_up_sd_card_read(sound_file) != -1) { size_of_wav++; } printf("Size of wav: %d\n", size_of_wav); if(alt_up_sd_card_fclose(sound_file)) printf("File closed.\n"); else printf("Error closing file.\n"); } */ size_of_wav = 875484; size_of_sound = (int) size_of_wav/200; //printf("Size of sound: %d\n", size_of_sound); //printf("Size of wav: %d\n", size_of_wav); sound_file = alt_up_sd_card_fopen("wav2.wav", false); if (sound_file != -1) { //printf("File opened.\n"); for(i = 0; i<size_of_wav; i++){ soundbuf[i] = alt_up_sd_card_read(sound_file); } /* * debugging WAV header * printf("ChunkSize: 0x%02x%02x%02x%02x\n", soundbuf[7], soundbuf[6], soundbuf[5], soundbuf[4]); printf("SubChunkSize: 0x%02x%02x%02x%02x\n", soundbuf[19], soundbuf[18], soundbuf[17], soundbuf[16]); printf("Audio Format: 0x%02x%02x\n", soundbuf[21], soundbuf[20]); printf("Channels : 0x%02x%02x\n", soundbuf[23], soundbuf[22]); printf("Samplerate: 0x%02x%02x%02x%02x\n", soundbuf[27], soundbuf[26], soundbuf[25], soundbuf[24]); printf("Bitrate: 0x%02x%02x%02x%02x\n", soundbuf[31], soundbuf[30], soundbuf[29], soundbuf[28]); printf("Blockalign: 0x%02x%02x\n", soundbuf[33], soundbuf[32]); printf("BitsPerSample: 0x%02x%02x\n", soundbuf[35], soundbuf[34]); printf("Data mark: %c%c%c%c\n", soundbuf[210], soundbuf[211], soundbuf[212], soundbuf[213]); printf("Subchunksize2: 0x%02x%02x%02x%02x\n", soundbuf[217], soundbuf[216], soundbuf[215], soundbuf[214]); datasize = soundbuf[217] * pow(16,6) + soundbuf[216] * pow(16,4) + soundbuf[215] * pow(16,2) + soundbuf[214]; printf("Datasize: %d\n", datasize); printf("Chunks:"); for (i = 218; i < 318; i++) { printf(" %02x", soundbuf[i]); } printf("\n"); */ for(i = 0; i<size_of_wav; i++){ if (soundbuf[i] == 'd') { if (soundbuf[i+1] == 'a'){ if (soundbuf[i+2] == 't'){ if (soundbuf[i+3] == 'a') { location = i; break; } } } } } i = location; for (k = 0; k<size_of_sound; k++) { for (j = 0; j<100; j++){ buffer[j] = convert(soundbuf[i+1], soundbuf[i]); i = i + 2; } arr[k] = (unsigned int*)malloc(sizeof(buffer)); memcpy((void*)arr[k], (void*)buffer, sizeof(buffer)); } } free(soundbuf); }
euint8 open_wav(SDfile fileinfo) { euint8 buff[600]; euint32 buff2[512]; euint32 right[512]; euint32 left[512]; euint8 leftovers[512]; euint8 leftoverCount=0; euint32 count = 0; euint32 i,zz; euint32 tempright; euint32 temp[5]; euint32 overflow_amount = 0; euint32 LoopC = 0; euint32 stuff_to_write = 0; euint32 ints_to_send = 0; euint32 sample_rate = 0; euint32 bitdepth = 0; euint32 channels = 0; euint32 formatcode = 0; euint32 blocksize = 0; euint32 header_size = 0; euint32 next_address = 0; euint32 clust_address = 0; euint32 FAT_address = 0; euint32 filesize = 0; euint32 end_offset = 0; euint32 bytes_read = 0; euint8 end_of_file = 0; alt_up_audio_dev* audio_dev = alt_up_audio_open_dev(AUDIO_NAME); alt_up_audio_reset_audio_core(audio_dev); filesize = fileinfo.file_size; FAT_address = (euint32)fileinfo.startL | ((euint32)fileinfo.startH)<<16; clust_address = (FAT_address-2)*Part_Boot.sec_per_clust + clust_start; sd_readSector(clust_address,buff); //read in wav header info bytes_read += 512; //address = next_sect_address(address); header_size = get_wav_header(buff,&sample_rate,&bitdepth,&channels,&formatcode,&blocksize); //psuedo code for reading in wav details, returns wav info if(formatcode != 1) { UART_write("Error: incorrect wav format type, please use PCM\n\r"); return(1); } if(channels != 2) { UART_write("Error, number of channels must be 2\n\r"); return(1); } if((bitdepth != 32)&&(bitdepth != 16)&&(bitdepth != 24)&&(bitdepth != 8)) { UART_write("Error, bitdepth is incorrect\n\r"); return(1); } if(sample_rate != 8000) { UART_write("Error, sample rate is incorrect\n\r"); return(1); } switch(sample_rate) { case 8000: AUDIO_SetSampleRate(RATE_ADC8K_DAC8K_USB); break; case 32000: AUDIO_SetSampleRate(RATE_ADC32K_DAC32K_USB); break; case 44100: AUDIO_SetSampleRate(RATE_ADC44K_DAC44K_USB); break; case 48000: AUDIO_SetSampleRate(RATE_ADC48K_DAC48K_USB); break; case 96000: AUDIO_SetSampleRate(RATE_ADC96K_DAC96K_USB); break; default: printf("Non-standard sampling rate\n"); return -1; } count = count + header_size; while(end_of_file == 0) //start reading bytes from offset position, if there are bytes to be read, continue { //convert char buffer into 32 bit buffer while(LoopC < Part_Boot.sec_per_clust) { if(bitdepth == 32) { for(i=0;i<128;i++) { *((unsigned char*)&buff2[i]+0) = buff[count+0]; *((unsigned char*)&buff2[i]+1) = buff[count+1]; *((unsigned char*)&buff2[i]+2) = buff[count+2]; *((unsigned char*)&buff2[i]+3) = buff[count+3]; count += 4; if(count > 512) { ints_to_send = i+1; break; } if(i==127) ints_to_send = i+1; } count = 0; } if(bitdepth == 24) { for(i=0;i<170;i++) // PROBLEM HERE PROBS SINCE 512/3 ISNT WHOLE NUMBER { *((unsigned char*)&buff2[i]+0) = 0; *((unsigned char*)&buff2[i]+1) = buff[count+0]; *((unsigned char*)&buff2[i]+2) = buff[count+1]; *((unsigned char*)&buff2[i]+3) = buff[count+2]; count += 3; if(count >= 512) { count = (count-512)+3; ints_to_send = i+1; break; } } } if(bitdepth == 16) { for(i=0;i<256;i++) { *((unsigned char*)&buff2[i]+0) = 0; *((unsigned char*)&buff2[i]+1) = 0; *((unsigned char*)&buff2[i]+2) = buff[count+0]; *((unsigned char*)&buff2[i]+3) = buff[count+1]; count += 2; if(count > 512) { ints_to_send = i+1; break; } if(i==255) ints_to_send = i+1; } count = 0; } if(bitdepth == 8) { for(i=0;i<512;i++) { *((unsigned char*)&buff2[i]+0) = 0; *((unsigned char*)&buff2[i]+1) = 0; *((unsigned char*)&buff2[i]+2) = 0; *((unsigned char*)&buff2[i]+3) = buff[count+0]; count++; if(count > 512) { ints_to_send = i+1; break; } if(i==511) ints_to_send = i+1; } count = 0; } // pass to left and right channels for(i=0;i<256;i++) { left[i] = buff2[i*2]; right[i] = buff2[i*2+1]; } if(end_offset != 0) { stuff_to_write = end_offset/(1024/ints_to_send); end_of_file = 1; end_offset = 0; } else { stuff_to_write = ints_to_send/2; } //is there space in the fifo? while(alt_up_audio_write_fifo_space(audio_dev,0) < stuff_to_write); //send to audio channels alt_up_audio_write_fifo(audio_dev,right,stuff_to_write,ALT_UP_AUDIO_RIGHT); alt_up_audio_write_fifo(audio_dev,left,stuff_to_write,ALT_UP_AUDIO_LEFT); clust_address++; sd_readSector(clust_address,buff); bytes_read += 512; LoopC++; if(bytes_read >= filesize) { end_of_file = 1; //end_offset = 512 - (bytes_read-filesize); } } LoopC = 0; clust_address = next_sect_address(FAT_address,&next_address); FAT_address = next_address; if(bytes_read >= filesize) { end_of_file = 1; //end_offset = 512 - (bytes_read-filesize); } } return(0); }