diff --git a/kitsune/3200.jscope b/kitsune/3200.jscope index 3a3a90db..ea9ba21d 100644 --- a/kitsune/3200.jscope +++ b/kitsune/3200.jscope @@ -10,7 +10,7 @@ - + @@ -19,10 +19,10 @@ - + - + diff --git a/kitsune/adpcm.c b/kitsune/adpcm.c new file mode 100644 index 00000000..1924648e --- /dev/null +++ b/kitsune/adpcm.c @@ -0,0 +1,277 @@ +/*********************************************************** +Copyright 1992 by Stichting Mathematisch Centrum, Amsterdam, The +Netherlands. + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the names of Stichting Mathematisch +Centrum or CWI not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior permission. + +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + +******************************************************************/ + +/* +** Intel/DVI ADPCM coder/decoder. +** +** The algorithm for this coder was taken from the IMA Compatability Project +** proceedings, Vol 2, Number 2; May 1992. +** +** Version 1.2, 18-Dec-92. +** +** Change log: +** - Fixed a stupid bug, where the delta was computed as +** stepsize*code/4 in stead of stepsize*(code+0.5)/4. +** - There was an off-by-one error causing it to pick +** an incorrect delta once in a blue moon. +** - The NODIVMUL define has been removed. Computations are now always done +** using shifts, adds and subtracts. It turned out that, because the standard +** is defined using shift/add/subtract, you needed bits of fixup code +** (because the div/mul simulation using shift/add/sub made some rounding +** errors that real div/mul don't make) and all together the resultant code +** ran slower than just using the shifts all the time. +** - Changed some of the variable names to be more meaningful. +*/ + +#include "adpcm.h" +#include +#include /*DBG*/ + +#ifndef __STDC__ +#define signed +#endif + +//#define ADPCM_ENDIAN_SWAP + + +#ifdef ADPCM_ENDIAN_SWAP +uint16_t swap_uint16( uint16_t val ) +{ + return (val << 8) | (val >> 8 ); +} + +//! Byte swap short +int16_t swap_int16( int16_t val ) +{ + return (val << 8) | ((val >> 8) & 0xFF); +} +#endif + +/* Intel ADPCM step variation table */ +static int indexTable[16] = { + -1, -1, -1, -1, 2, 4, 6, 8, + -1, -1, -1, -1, 2, 4, 6, 8, +}; + +static int stepsizeTable[89] = { + 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, + 19, 21, 23, 25, 28, 31, 34, 37, 41, 45, + 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, + 130, 143, 157, 173, 190, 209, 230, 253, 279, 307, + 337, 371, 408, 449, 494, 544, 598, 658, 724, 796, + 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066, + 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358, + 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899, + 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767 +}; + +void adpcm_coder(short *indata, char *outdata, int len, adpcm_state *state) +{ + short *inp; /* Input buffer pointer */ + signed char *outp; /* output buffer pointer */ + int val; /* Current input sample value */ + int sign; /* Current adpcm sign bit */ + int delta; /* Current adpcm output value */ + int diff; /* Difference between val and valprev */ + int step; /* Stepsize */ + int valpred; /* Predicted output value */ + int vpdiff; /* Current change to valpred */ + int index; /* Current step change index */ + int outputbuffer; /* place to keep previous 4-bit value */ + int bufferstep; /* toggle between outputbuffer/output */ + short tmp; + + outp = (signed char *)outdata; + inp = indata; + + valpred = state->valprev; + index = state->index; + step = stepsizeTable[index]; + + bufferstep = 1; + + for ( ; len > 0 ; len-- ) { +#ifdef ADPCM_ENDIAN_SWAP + tmp = swap_int16(*inp); + inp++; + val = tmp; +#else + val = *inp++; +#endif + + /* Step 1 - compute difference with previous value */ + diff = val - valpred; + sign = (diff < 0) ? 8 : 0; + if ( sign ) diff = (-diff); + + /* Step 2 - Divide and clamp */ + /* Note: + ** This code *approximately* computes: + ** delta = diff*4/step; + ** vpdiff = (delta+0.5)*step/4; + ** but in shift step bits are dropped. The net result of this is + ** that even if you have fast mul/div hardware you cannot put it to + ** good use since the fixup would be too expensive. + */ + delta = 0; + vpdiff = (step >> 3); + + if ( diff >= step ) { + delta = 4; + diff -= step; + vpdiff += step; + } + step >>= 1; + if ( diff >= step ) { + delta |= 2; + diff -= step; + vpdiff += step; + } + step >>= 1; + if ( diff >= step ) { + delta |= 1; + vpdiff += step; + } + + /* Step 3 - Update previous value */ + if ( sign ) + valpred -= vpdiff; + else + valpred += vpdiff; + + /* Step 4 - Clamp previous value to 16 bits */ + if ( valpred > 32767 ) + valpred = 32767; + else if ( valpred < -32768 ) + valpred = -32768; + + /* Step 5 - Assemble value, update index and step values */ + delta |= sign; + + index += indexTable[delta]; + if ( index < 0 ) index = 0; + if ( index > 88 ) index = 88; + step = stepsizeTable[index]; + + /* Step 6 - Output value */ + if ( bufferstep ) { + outputbuffer = (delta << 4) & 0xf0; + } else { + *outp++ = (delta & 0x0f) | outputbuffer; + } + bufferstep = !bufferstep; + } + + /* Output last step, if needed */ + if ( !bufferstep ) + *outp++ = outputbuffer; + + state->valprev = valpred; + state->index = index; +} + + +void adpcm_decoder(char *indata, short *outdata, int len, adpcm_state *state) +{ + signed char *inp; /* Input buffer pointer */ + short *outp; /* output buffer pointer */ + int sign; /* Current adpcm sign bit */ + int delta; /* Current adpcm output value */ + int step; /* Stepsize */ + int valpred; /* Predicted value */ + int vpdiff; /* Current change to valpred */ + int index; /* Current step change index */ + int inputbuffer; /* place to keep next 4-bit value */ + int bufferstep; /* toggle between inputbuffer/input */ + short tmp; + outp = outdata; + inp = (signed char *)indata; + + valpred = state->valprev; + index = state->index; + step = stepsizeTable[index]; + + bufferstep = 0; + + for ( ; len > 0 ; len-- ) { + + /* Step 1 - get the delta value */ + if ( bufferstep ) { + delta = inputbuffer & 0xf; + } else { + inputbuffer = *inp++; + delta = (inputbuffer >> 4) & 0xf; + } + bufferstep = !bufferstep; + + /* Step 2 - Find new index value (for later) */ + index += indexTable[delta]; + if ( index < 0 ) index = 0; + if ( index > 88 ) index = 88; + + /* Step 3 - Separate sign and magnitude */ + sign = delta & 8; + delta = delta & 7; + + /* Step 4 - Compute difference and new predicted value */ + /* + ** Computes 'vpdiff = (delta+0.5)*step/4', but see comment + ** in adpcm_coder. + */ + vpdiff = step >> 3; + if ( delta & 4 ) vpdiff += step; + if ( delta & 2 ) vpdiff += step>>1; + if ( delta & 1 ) vpdiff += step>>2; + + if ( sign ) + valpred -= vpdiff; + else + valpred += vpdiff; + + /* Step 5 - clamp output value */ + if ( valpred > 32767 ) + valpred = 32767; + else if ( valpred < -32768 ) + valpred = -32768; + + /* Step 6 - Update step value */ + step = stepsizeTable[index]; + + /* Step 7 - Output value */ +#ifdef ADPCM_ENDIAN_SWAP + tmp = valpred; + tmp = swap_int16(tmp); + *outp++ = tmp; +#else + *outp++ = valpred; +#endif + + } + + state->valprev = valpred; + state->index = index; +} + + + diff --git a/kitsune/adpcm.h b/kitsune/adpcm.h new file mode 100644 index 00000000..bc1054d3 --- /dev/null +++ b/kitsune/adpcm.h @@ -0,0 +1,22 @@ +/* +** adpcm.h - include file for adpcm coder. +** +** Version 1.0, 7-Jul-92. +*/ + +#ifndef _ADPCM_H_ +#define _ADPCM_H_ + +typedef struct adpcm_state_t { + short valprev; /* Previous output value */ + char index; /* Index into stepsize table */ +}adpcm_state; + + +void adpcm_coder(short *indata, char *outdata, int len, adpcm_state *state); + +void adpcm_decoder(char *indata, short *outdata, int len, adpcm_state *state); + + +#endif + diff --git a/kitsune/audiotask.c b/kitsune/audiotask.c index 4c347555..5273f38c 100644 --- a/kitsune/audiotask.c +++ b/kitsune/audiotask.c @@ -27,6 +27,7 @@ #include "kit_assert.h" #include "utils.h" +#include "adpcm.h" #include "hlo_async.h" #include "state.pb.h" @@ -43,8 +44,6 @@ #define MAX_NUMBER_TIMES_TO_WAIT_FOR_AUDIO_BUFFER_TO_FILL (5) #define MAX_FILE_SIZE_BYTES (1048576*10) -#define MONO_BUF_LENGTH (256) - #define FLAG_SUCCESS (0x01) #define FLAG_STOP (0x02) @@ -255,7 +254,8 @@ static uint8_t DoPlayback(const AudioPlaybackDesc_t * info) { #define FLASH_PAGE_SIZE 512 //1.5K on the stack - uint16_t * speaker_data = pvPortMalloc(SPEAKER_DATA_CHUNK_SIZE+1); + short * speaker_data = pvPortMalloc(FLASH_PAGE_SIZE+1); + char * speaker_data_enc = pvPortMalloc(FLASH_PAGE_SIZE/4+1); FIL fp = {0}; UINT size; @@ -313,6 +313,7 @@ static uint8_t DoPlayback(const AudioPlaybackDesc_t * info) { } LOGI("%d free %d stk\n", xPortGetFreeHeapSize(), uxTaskGetStackHighWaterMark(NULL)); + adpcm_state pcm_state = {0}; memset(speaker_data,0,SPEAKER_DATA_CHUNK_SIZE); _queue_audio_playback_state(PLAYING, info); @@ -320,6 +321,7 @@ static uint8_t DoPlayback(const AudioPlaybackDesc_t * info) { for (; ;) { /* Read always in block of 512 Bytes or less else it will stuck in hello_fs_read() */ res = hello_fs_read(&fp, speaker_data, FLASH_PAGE_SIZE, &size); + adpcm_coder( speaker_data, speaker_data_enc, size/2, &pcm_state ); if ( res == FR_OK && size > 0 ) { /* Wait to avoid buffer overflow as reading speed is faster than playback */ @@ -389,7 +391,7 @@ static uint8_t DoPlayback(const AudioPlaybackDesc_t * info) { } } - FillBuffer(pRxBuffer, (unsigned char*) (speaker_data), size); + FillBuffer(pRxBuffer, (unsigned char*) (speaker_data_enc), size/4); } else { if( res != 0 ) { @@ -415,6 +417,7 @@ static uint8_t DoPlayback(const AudioPlaybackDesc_t * info) { LOGI("leftover %d\n", GetBufferSize(pRxBuffer)); vPortFree(speaker_data); + vPortFree(speaker_data_enc); ///CLEANUP DeinitAudioPlayback(); @@ -436,7 +439,8 @@ static uint8_t DoPlayback(const AudioPlaybackDesc_t * info) { static void DoCapture(uint32_t rate) { - int16_t * samples = pvPortMalloc(MONO_BUF_LENGTH*2*2); //256 * 2bytes * 2 = 1KB + int16_t * samples = pvPortMalloc(PING_PONG_CHUNK_SIZE*4); + char * adpcm = pvPortMalloc(PING_PONG_CHUNK_SIZE); char filepath[32]; int iBufferFilled = 0; @@ -465,6 +469,8 @@ static void DoCapture(uint32_t rate) { InitAudioCapture(rate); + adpcm_state pcm_state = {0}; + LOGI("%d free %d stk\n", xPortGetFreeHeapSize(), uxTaskGetStackHighWaterMark(NULL)); //loop until we get an event that disturbs capture @@ -591,7 +597,9 @@ static void DoCapture(uint32_t rate) { } else { //dump buffer out - ReadBuffer(pTxBuffer,(uint8_t *)samples,PING_PONG_CHUNK_SIZE); + ReadBuffer(pTxBuffer,(uint8_t *)adpcm,PING_PONG_CHUNK_SIZE); + + adpcm_decoder( adpcm, samples, PING_PONG_CHUNK_SIZE*2, &pcm_state ); #ifdef PRINT_TIMING t1 = xTaskGetTickCount(); dt = t1 - t0; t0 = t1; @@ -599,7 +607,7 @@ static void DoCapture(uint32_t rate) { //write to file if (isSavingToFile) { - const uint32_t bytes_written = MONO_BUF_LENGTH*sizeof(int16_t); + const uint32_t bytes_written = PING_PONG_CHUNK_SIZE*2*sizeof(int16_t); if (WriteToFile(&filedata,bytes_written,(const uint8_t *)samples)) { num_bytes_written += bytes_written; @@ -652,6 +660,7 @@ static void DoCapture(uint32_t rate) { CAPTURE_CLEANUP: vPortFree(samples); + vPortFree(adpcm); if (isSavingToFile) { CloseAndDeleteFile(&filedata); diff --git a/kitsune/commands.c b/kitsune/commands.c index de3bf0fd..ec331af9 100644 --- a/kitsune/commands.c +++ b/kitsune/commands.c @@ -609,11 +609,12 @@ static bool cancel_alarm() { } int set_test_alarm(int argc, char *argv[]) { + while(1) { SyncResponse_Alarm alarm; unsigned int now = get_time(); - alarm.end_time = now + 245; + alarm.end_time = now + 45; alarm.start_time = now + 5; - alarm.ring_duration_in_second = 240; + alarm.ring_duration_in_second = 40; alarm.ring_offset_from_now_in_second = 5; strncpy(alarm.ringtone_path, "/ringtone/tone.raw", strlen("/ringtone/tone.raw")); @@ -629,6 +630,9 @@ int set_test_alarm(int argc, char *argv[]) { usnprintf(ack, 32, "%d", now); set_alarm(&alarm, ack, strlen(ack)); + vTaskDelay(10000); + } + return 0; } static void thread_alarm_on_finished(void * context) { @@ -733,7 +737,7 @@ void thread_alarm(void * unused) { strncpy(desc.file, file_name, 64); desc.durationInSeconds = alarm.ring_duration_in_second; - desc.volume = 57; + desc.volume = 10; desc.onFinished = thread_alarm_on_finished; desc.rate = 48000; desc.context = &alarm_led_id; diff --git a/kitsune/main/ccs/.cproject b/kitsune/main/ccs/.cproject index 8c1adeac..4c7041fe 100644 --- a/kitsune/main/ccs/.cproject +++ b/kitsune/main/ccs/.cproject @@ -139,6 +139,14 @@ + + + + + + + + - - - - - - - -