Diff: signal_processing.cpp

Revision:

4:99de9b4005d2

Parent:

3:51e15bd15778

Child:

5:a658cda1d619

--- a/signal_processing.cpp	Mon Mar 02 23:33:16 2020 +0000
+++ b/signal_processing.cpp	Wed Mar 04 00:55:43 2020 +0000
@@ -30,9 +30,10 @@
 
 #define AUDIO_BLOCK_SAMPLES             ((uint32_t)128)         // Number of samples (L and R) in audio block (each samples is 16 bits)
 #define BUFFER_LENGTH                   (WIN_NUM_TAPS + AUDIO_BLOCK_SAMPLES - 1)
+#define FFT_BUFFER_LENGTH                2048
 
 /* For Lab Exercise */
-#define Lab_Execution_Type              2
+#define Lab_Execution_Type              3
 
 float32_t lState[NUM_TAPS + AUDIO_BLOCK_SAMPLES - 1];
 float32_t rState[NUM_TAPS + AUDIO_BLOCK_SAMPLES - 1];
@@ -40,21 +41,25 @@
 float32_t l_buf[BUFFER_LENGTH];
 float32_t r_buf[BUFFER_LENGTH];
 
-float32_t* l_buf_head = l_buf;
-uint16_t l_buf_head_idx = 0;
-float32_t* r_buf_head = r_buf;
-uint16_t r_buf_head_idx = 0;
-
 arm_fir_instance_f32 filter_left;
 arm_fir_instance_f32 filter_right;
 
+float32_t fft_buf[FFT_BUFFER_LENGTH];
+
+float32_t fft_of_filter[FFT_BUFFER_LENGTH];
+
+
+
+
+
 /* FUNCTION DEFINITIONS BELOW */
 
 /**
   * @brief  Initialize filter structures to be used in loops later
   * @retval None
   */
-void initalize_signal_processing(void) {
+void initalize_signal_processing(void)
+{
 
   switch (Lab_Execution_Type)
   {
@@ -72,10 +77,19 @@
     break;
   
   case 3: // FFT Overlap-add 
-  filter_init();
+  filter_conv_init();
     break;
     
-  case 4: // FFT Overlap-add with real-imag efficiency
+  case 4: // FFT Overlap-add
+    filter_fft_init();
+    break;
+
+  case 5: // FFT Overlap-add with real-imag efficiency
+    filter_fft_init();
+    break;
+    
+  case 6: // OS FFT RI
+    filter_fft_init();
     break;
 
 
@@ -116,12 +130,22 @@
   arm_fir_f32(&filter_right, R_channel_in, R_channel_out, Signal_Length);
     break;
   
-  case 3: // FFT Overlap-add 
-  filter(l_buf, l_buf_head, l_buf_head_idx, L_channel_in, L_channel_out, Signal_Length, BUFFER_LENGTH);
-  filter(r_buf, r_buf_head, r_buf_head_idx, R_channel_in, R_channel_out, Signal_Length, BUFFER_LENGTH);
+  case 3: // OA CONV
+  filter_OA_CONV(l_buf, L_channel_in, L_channel_out, Signal_Length, BUFFER_LENGTH);
+  filter_OA_CONV(r_buf, R_channel_in, R_channel_out, Signal_Length, BUFFER_LENGTH);
     break;
     
-  case 4: // FFT Overlap-add with real-imag efficiency
+  case 4: // OA FFT Overlap-add
+ 
+    break;
+
+  case 5: // FFT Overlap-add with real-imag efficiency
+ 
+    break;
+    
+  case 6: // OS FFT RI
+ 
+ 
     break;
 
     
@@ -132,15 +156,15 @@
 
 //buffer: pointer to the storage buffer for the filter output
 //buf_length: the length of the storage buffer (len_filter + len_batch - 1)
-void filter(float32_t* buffer_begin, float32_t* buffer_head, uint16_t buffer_head_idx, float32_t* d_in, float32_t* d_out, uint16_t sig_length, uint16_t buf_length)
+void filter_OA_CONV(float32_t* overlap_buffer, float32_t* d_in, float32_t* d_out, uint16_t sig_length, uint16_t buf_length)
 {
-    float32_t* data_sample = d_in+sig_length-1;
+    float32_t* data_sample = d_in;
     float32_t* filter_sample = win_filter_coeffs;
     float32_t result = 0;
     uint16_t conv_length = 0;
-    float32_t* buffer_data_location = buffer_head;
     
     //convolve and save to buffer
+    /*
     for(uint16_t shift = 0; shift < buf_length; shift++)
     {
         //shift
@@ -161,13 +185,71 @@
         //multiply-add
         for(int i=0; i<conv_length; i++)
         {
-            result += (*filter_sample) * (*data_sample);
-            filter_sample++;
-            data_sample--;
+            result += (filter_sample[i]) * (data_sample[shift - i]);
         }
         
         // save to the buffer
-        *buffer_data_location += result;
+        overlap_buffer[shift] += result;
+    }
+    */
+    for(int i=0; i < buf_length; i++)
+    {
+        if(i < sig_length)
+        {
+            overlap_buffer[i] = data_sample[i];
+        }
+        else
+        {
+            overlap_buffer[i] = 0;
+        }
+    }
+    
+    //copy from buffer to d_out, shift buffer, zero pad
+    for(int i=0; i < buf_length; i++)
+    {
+        if(i < sig_length)
+        {
+            d_out[i] = overlap_buffer[i];
+            overlap_buffer[i] = overlap_buffer[i+sig_length];
+        }
+        else
+        {
+            overlap_buffer[i] = 0;
+        }
+    }
+    return;
+}
+
+
+
+void filter_OA_FFT(float32_t* buffer_begin, float32_t* buffer_head, uint16_t buffer_head_idx, float32_t* d_in, float32_t* d_out, uint16_t sig_length, uint16_t buf_length)
+{
+    /*float32_t* data_sample = d_in+sig_length-1;
+    float32_t* filter_sample = win_filter_coeffs;
+    float32_t result = 0;
+    float32_t* buffer_data_location = buffer_head;
+    
+    for(uint16_t i = 0; i < FFT_BUFFER_LENGTH; i++)
+    {
+        fft_buf[i] = d_in[i];
+    }
+    
+    arm_cfft_f32(&arm_cfft_sR_f32_len1024, fft_buf, 0, 1);
+    
+    for(uint16_t i = 0; i < FFT_BUFFER_LENGTH; i++)
+    {
+        fft_buf[i] = fft_buf[i]*fft_of_filter[i];
+    }
+    
+    arm_cfft_f32(&arm_cfft_sR_f32_len1024, fft_buf, 1, 1);
+    
+    
+    // save to buffer
+    for(uint16_t i = 0; i < buf_length; i++)
+    {        
+        
+        // save to the buffer
+        *buffer_data_location += fft_buf[i];
         //increment, looping back to beginning of buffer
         if(buffer_data_location == (buffer_begin + buf_length - 1))
         {
@@ -194,11 +276,30 @@
         {
             buffer_data_location++;
         }
-    }
+    }*/
+    return;
+}
+
+
+    
+void filter_OA_FFT_RI(float32_t* buffer_begin, float32_t* buffer_head, uint16_t buffer_head_idx, float32_t* d_in, float32_t* d_out, uint16_t sig_length, uint16_t buf_length)
+{
     return;
 }
 
-void filter_init()
+
+
+void filter_OS_FFT_RI(float32_t* buffer_begin, float32_t* buffer_head, uint16_t buffer_head_idx, float32_t* d_in, float32_t* d_out, uint16_t sig_length, uint16_t buf_length)
+{
+    return;
+}
+
+
+
+
+
+
+void filter_conv_init()
 {
     for(int i=0; i < BUFFER_LENGTH; i++)
     {
@@ -207,3 +308,24 @@
     }
     return;
 }
+
+
+
+void filter_fft_init()
+{
+    for(int i=0; i < FFT_BUFFER_LENGTH; i++)
+    {
+        if(i < WIN_NUM_TAPS)
+        {
+         fft_of_filter[i] = win_filter_coeffs[i];
+        }
+        else
+        {
+         fft_of_filter[i] = 0;   
+        }
+    }
+    
+    arm_cfft_f32(&arm_cfft_sR_f32_len1024, fft_of_filter, 0, 1);
+    
+    return;
+}