path: root/WasmAudio/main.c

//
//  main.c
//  WasmAudio
//
//  Created by Jacky Jack on 06/07/2021.
//

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <getopt.h>
#include <signal.h>
#include <fcntl.h>
#include <pthread.h>
#include <unistd.h>



#if __EMSCRIPTEN__
#include <emscripten/emscripten.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_audio.h>
#include <GLES2/gl2.h>
#else
    #include <SDL2/SDL.h>
    #include <SDL2/SDL_audio.h>
    #ifdef __APPLE__
    #include <SDL2_ttf/SDL_ttf.h>
    #else
    #include <SDL2/SDL_ttf.h>
    #endif
    //how to use on mac?
    //#include <GLES2/gl2.h>
#endif


#ifdef __EMSCRIPTEN__
#define KEEPALIVE EMSCRIPTEN_KEEPALIVE
#else
#define KEEPALIVE
#endif

#include "../FIR/firmath.h"

#define SCREEN_WIDTH   320
#define SCREEN_WIDTH2  (SCREEN_WIDTH/2)
#define SCREEN_HEIGHT  320
#define SCREEN_HEIGHT2 (SCREEN_HEIGHT/2)

#define BUFSIZE 1536000
#define BUFSIZE2 (BUFSIZE/2)
#define BUFSIZE4 (BUFSIZE/4)
#define BUFSIZE8 (BUFSIZE/8)
#define BUFSIZE16 (BUFSIZE/16)

//Maximum recording time plus padding
#define RECORDING_BUFFER_SECONDS  (2)
//Maximum recording time
#define MAX_RECORDING_SECONDS (RECORDING_BUFFER_SECONDS+2)

//SDL drawing recording
int first_run=1;
static int quit=0;
static SDL_Window *window = NULL;
static SDL_Renderer *renderer = NULL;
//Audio device IDs
static SDL_AudioDeviceID recordingDeviceId = 0;
static SDL_AudioDeviceID playbackDeviceId = 0;
int audio_buf_position=0;
int current_state=0;

//audio buffer vars
int audio_rec_buffer_size=-1;
int audio_rec_buffer_max_size=-1;
static uint8_t audio_rec_buffer_[BUFSIZE];
#define PROCESS_BUF_SIZE (BUFSIZE4)
static double process_buf[PROCESS_BUF_SIZE+100];
static double process_buf2[PROCESS_BUF_SIZE+100];
uint8_t *audio_rec_buffer=NULL;

//FIR filter stuff
FILE *f_1,*f_2;
fir_t fir_lp;
firw_t firw_lp;
const int N=200;
double h[N],w[N];
int filter_N=60;
int filter_FS_hz=48000;
int filter_FC_hz=1000;
double filter_FC;

void audio_recording_callback(void *data, uint8_t *insamples, int len) {
    if (audio_buf_position<audio_rec_buffer_size) {
        memcpy( audio_rec_buffer+audio_buf_position, insamples, len);
        audio_buf_position += len;
    }
    
}

void audio_playback_callback(void *data, uint8_t *outsamples, int len) {
    //printf("call play\n");
    if (audio_buf_position<audio_rec_buffer_size) {
        memcpy( outsamples, audio_rec_buffer+audio_buf_position,len);
        audio_buf_position += len;
    }
    
}

//The various recording actions we can take
enum RecordingState
{
    SELECTING_DEVICE,
    STOPPED,
    RECORDING,
    RECORDED,
    PLAYBACK,
    ERROR
};

void convert_double_to_f32() {
    int i=0;
    
    for (i=0;i<BUFSIZE2;i+=4) {
        double d = process_buf[i/4];
        if (i/4 > BUFSIZE4) {
            printf("Buffer overflow convert_double_to_f32");
            exit(1);
        }
        float f = d;
        int32_t *i32_ = &f,i32=*i32_;
        
        audio_rec_buffer[i+3] = ((int)i32>>24)&0xff;
        audio_rec_buffer[i+2] = ((int)i32>>16)&0xff;
        audio_rec_buffer[i+1] = ((int)i32>>8)&0xff;
        audio_rec_buffer[i+0] =  ((int)i32&0xff);
    
    }
    //printf("\n");
}
 


void convert_f32_to_double() {
    int i=0;
    for (i=0;i<BUFSIZE2;i+=4) {
        int32_t i32 = ((audio_rec_buffer[i+3] << 24) | (audio_rec_buffer[i+2] << 16) | (audio_rec_buffer[i+1] << 8) | (audio_rec_buffer[i+0]) );
        float *ff = &i32;

        //double d = f;
        if ((i/4)<BUFSIZE4) {
            process_buf[i/4] = *ff;
        } else {
            printf("Buffer overflow convert_f32_to_double\n");
            exit(0);
        }
        //printf("%f %f\n",ff,process_buf[i/4]);
    }
    
}

int KEEPALIVE get_sample_rate() {
    return filter_FS_hz;
}

void set_sample_rate() {
    
}

void set_cutoff_freq(int cutoff) {
    if (cutoff < 0) {
        cutoff = 0;
        filter_FC_hz = cutoff;
        return;
    }
    
    if (cutoff > filter_FS_hz/2) {
        cutoff = filter_FS_hz/2;
        filter_FC_hz = cutoff;
        filter_FC=1.0*cutoff/filter_FS_hz;
        return;
    }
}

int KEEPALIVE get_cutoff_freq() {
    return filter_FC_hz;
}

int KEEPALIVE get_tap_number() {
    return filter_N;
}

void set_tap_number(int tapN) {
    if (tapN<10) {
        tapN = 10;
        return;
        
    }
}

int KEEPALIVE  recalculate_fir() {
    int i = 0;
    filter_FC=1.0*filter_FC_hz/filter_FS_hz;
    fir_lp.num_taps =filter_N;
    fir_lp.fir_coef = h;
    firw_lp.num_taps = filter_N;
    firw_lp.win_coef = w;
        
    for (i=0;i<N;i++) {
        h[i] = 0.0;
        w[i] = 0.0;
    }
    
    fir_init(&fir_lp, filter_N);
    firw_init(&firw_lp, filter_N);
    fir_sinc_lp(&fir_lp, filter_FC);
    //fir_sinc_hp(&fir_lp, filter_FC);
    firw_blackman(&firw_lp);
    //firw_rect(&firw_lp);
    fir_convolute(&fir_lp, &firw_lp);
    //fir_print_matlab(&fir_lp);
    return 0;
}


void convert_dobule_up() {
    int i=0;
    for (i=0;i<BUFSIZE4;i++) {
        //process_buf[i] = 0.0;
        //printf("%f -> ",process_buf[i]);
        process_buf[i] = process_buf[i]*1.01;
        if (process_buf[i] > 1.0) process_buf[i] = 1.0;
        if (process_buf[i] < -1.0) process_buf[i] = -1.0;
        //printf("%f\n",process_buf[i]);
    }
}

void save_to_matlab(char *name) {
    int i;
    FILE *f=NULL;
    char namebuf[256];
    snprintf(namebuf,sizeof(namebuf),"%s.mat",name);
    f = fopen(namebuf,"w+");
    fprintf(f,"# Created by me\n");
    fprintf(f,"# name: %s\n",name);
    fprintf(f,"# type: matrix\n");
    fprintf(f,"# rows: 1\n");
    int dumpSize=BUFSIZE16;
    fprintf(f,"# columns: %d\n",dumpSize);
    
#if 1
    for (i=0;i<dumpSize;i++) {
        float f1=2.0f;
        fprintf(f," %.4f",process_buf[i]);
        printf(" %.4f",process_buf[i]);
    }
#endif
#if 0
    for (i=0;i<dumpSize;i+=4) {
        
        int32_t i32 = (float)((audio_rec_buffer[i+0] << 24) | (audio_rec_buffer[i+1] << 16) | (audio_rec_buffer[i+2] << 8) | (audio_rec_buffer[i+3]) );
        float ff=i32;
        fprintf(f," %.3f",ff);
        //printf(" %.3f",ff);
        
    }
#endif
    fprintf(f,"\n\n\n");
    
    fclose(f);
}

#define MIN(x, y) (((x) < (y)) ? (x) : (y))
void fir_filter(fir_t *fir, double *input, uint32_t ilength, double *output, uint32_t olength) {
    double acc;
        double *coeffp;
        double *inputp;
        int n;
        int k;

        memcpy(&input[fir->num_taps-1], input, ilength*sizeof(double));

        for (n=0; n<ilength; n++)
        {
            coeffp = fir->fir_coef;
            inputp = &input[fir->num_taps - 1 + n];
            acc = 0;

            for (k=0;k<fir->num_taps;k++)
            {
                acc += (*coeffp++)*(*inputp--);
            }

            output[n] = acc;
        }

        memmove(&input[0], &input[ilength], (fir->num_taps-1)*sizeof(double));
}

uint32_t tick_start, tick_end,tick_1sec;

#if __EMSCRIPTEN__
void main_tick() {
#else
int main_tick() {
#endif
    int i;
    int update_fractal=0;
    uint64_t perf_start;
    
    perf_start = SDL_GetPerformanceCounter();
    tick_start = SDL_GetTicks();
    
    SDL_Event event;
    SDL_StartTextInput();
        while (SDL_PollEvent(&event) != 0)
        {
                    
            switch (event.type)
            {
                case SDL_QUIT:
                {
                    quit = 1;
                    break;
                }
                case SDL_KEYDOWN:
                {
                    switch (event.key.keysym.sym)
                    {

                    case 21:
                    case SDLK_r:
                            //record if stopped
                            if ((current_state == STOPPED) || (current_state == RECORDED)) {
                                audio_buf_position = 0;
                                SDL_PauseAudioDevice(recordingDeviceId, SDL_FALSE);
                                current_state = RECORDING;
                                printf("State: RECORDING\n");
                            }
                        break;
                    case 22:
                    case SDLK_s:
                            //play if recorded
                            if (current_state == RECORDED) {
                                audio_buf_position = 0;
                                SDL_PauseAudioDevice( playbackDeviceId, SDL_FALSE );
                                current_state = PLAYBACK;
                                printf("State: PLAYBACK\n");
                            } /*else if (current_state == PLAYBACK) {
                                current_state = STOPPED;
                            } else if (current_state == STOPPED) {
                                current_state = PLAYBACK;
                            }*/
                        break;
                    case 20:
                    case SDLK_q:
                            //process recorderd buffer with low pass filter
                            if (current_state == RECORDED) {
                                convert_f32_to_double();
                                save_to_matlab("B1");
                                //simple volume raise
#if 0
                                convert_dobule_up();
#endif
                                //fir filter apply
#if 1
                
                                fir_filter(&fir_lp, process_buf, PROCESS_BUF_SIZE, process_buf2, PROCESS_BUF_SIZE);
                                memcpy(process_buf,process_buf2,PROCESS_BUF_SIZE*sizeof(double));
                                save_to_matlab("B2");
#endif
                                convert_double_to_f32();
                            }
                        break;
                    default:
                        printf("Unknown key %d\n",event.key.keysym.sym);
                        update_fractal = 1;
                    }
                    break;
                }
            }
            //printf("Poll event\n");
            
        }
#if __EMSCRIPTEN__
        if (current_state == RECORDING) {
            SDL_LockAudioDevice( recordingDeviceId );
            printf("recording=%d\n",audio_buf_position);
            if( audio_buf_position > audio_rec_buffer_size )
            {
                //Stop recording audio
                SDL_PauseAudioDevice( recordingDeviceId, SDL_TRUE );
                current_state = RECORDED;
                printf("State: RECORDED\n");
            }
            
            SDL_UnlockAudioDevice( recordingDeviceId );
        } else if (current_state == PLAYBACK) {
            SDL_LockAudioDevice( playbackDeviceId );
            //Finished playback