audio.c

Go to the documentation of this file.

/************************************************************************//**
 * \file heivs/audio.c
 * \brief ARMEBS4 audio
 * \author marc dot pignat at hevs dot ch & Pascal Sartoretti (sap at hevs dot ch)
 ***************************************************************************/

#include "heivs/audio.h"
#include "heivs/audio_stm32.h"
#include "heivs/audio_codec.h"
#include "stm32/stm32f4xx_rcc.h"
#include "stm32/stm32f4xx_spi.h"
#include "stm32/stm32f4xx_dma.h"
#include "stm32/stm32f4xx_misc.h"
#include "heivs/delay.h"
#include "heivs/time.h"
#include <math.h>

#include "heivs/config.h"
#if USE_FREERTOS
#include "freertos/FreeRTOS.h"
#endif


/**
 * A fast sine wave generator, by Charles Praplan
 *
 * The following difference equation implements an IIR filter whose poles
 * are on the unit circle if -2 < f_a < 2.
 *
 *            A*sin(2*pi*f0/FS)
 *  H(z) = -----------------------
 *         1 - f_a*(z^-1) + (z^-2)
 *
 * We are here interested in the impulse response which is a pure sine wave.
 * Instead of applying a delta impulse at the input of the system we provide
 * initial conditions.
 *
 * If a little change occurs in the 'a' (due to numerical precision), the
 * stability is maintained as far the coefficient 'a' stays in the limits
 * mentioned above. But both the frequency and the amplitude of the wave change.
 *
 * The start conditions of the digital oscillator implemented in the
 * sine_wave_sample function are 2 succeeding samples of the sine wave.
 * This 2 values and the knowledge of the frequency (contained in the
 * coefficient 'a') determine completely the sine wave.
 *
 * We calculate here the start conditions for k = -1 and k = 0 so that
 * the first calculated sample is non zero if phase = 0.
 */
struct sine_wave_state_t
{
    float f_a;
    float af_Y[2];
};

/**
 * \brief Fast sine wave generator initialization
 *
 * \param state, the internal state of the generator
 * \param amplitude, the amplitude of the sine wave
 * \param fs, the sampling frequency (in Hz)
 * \param frequency, the sine frequency (in Hz)
 * \param phase, the start phase (in radians)
 *
 * \return #NO_ERROR for no problem
 *
 * \see sine_wave_sample
 *
 * \warning : on a TMS320C6211, the amplitude of the sine wave increases slowly
 */
static void init_sine_wave_float(struct sine_wave_state_t *state, float amplitude, float fs, float frequency, float phase)
{
  state->f_a  = 2 * cos(2 * M_PI * frequency/fs);
  state->af_Y[1] = amplitude * sin(-2 * M_PI * frequency/fs + phase);
  state->af_Y[0] = amplitude * sin(phase);
}

/**
 * \brief Fast sine wave generator
 *
 * \param state, the internal state of the generator
 * \return the value of the current sample
 *
 * \see sine_wave_init
 */
static float gen_sine_wave_float(struct sine_wave_state_t *state)
{
    float result;
    result = state->f_a * state->af_Y[0] - state->af_Y[1];

    state->af_Y[1] = state->af_Y[0];
    state->af_Y[0] = result;

    return result;
}

status_e Audio_Stream_Play_Init(uint32_t length, void *buffer0, void *buffer1, void (*done)(const void *))
{
    return AudioSTM32_Stream_Play_Init(length, buffer0, buffer1, done);
}

status_e Audio_Stream_Play_Stop(void)
{
    return AudioSTM32_Stream_Play_Stop();
}

status_e Audio_Stream_Play_Status(void)
{
    return AudioSTM32_Stream_Play_Status();
}

status_e Audio_Stream_Play_Pause(void)
{
    return AudioSTM32_Stream_Play_Pause();
}

status_e Audio_Stream_Play(const void *data)
{
    return AudioSTM32_Stream_Play(data);
}

status_e Audio_Stream_Record_Init(uint32_t length, void *buffer0, void *buffer1, void(*done)(const void *))
{
    return AudioSTM32_Stream_Record_Init(length, buffer0, buffer1, done);
}

status_e Audio_Stream_Record_Stop(void)
{
    return AudioSTM32_Stream_Record_Stop();
}

struct setup_t
{
    uint32_t fs;
    uint32_t byte_per_sample;
};

static struct setup_t setup;

status_e Audio_Init(uint32_t fs, uint32_t sample_size)
{
    status_e status;
    setup.fs = fs;

    switch (sample_size)
    {
    case 16:
        setup.byte_per_sample = 2;
    break;
    case 24:
        setup.byte_per_sample = 3;
    break;
    case 32:
        setup.byte_per_sample = 4;
    break;
    default:
    return ERROR_BAD_PARAM;
    }

    status = AudioCodec_Init(fs);
    if (status != NO_ERROR)
    {
        return status;
    }

    Audio_SetVolumeHeadphone(0);
    Audio_SetVolumeSpeaker(0);

    status = AudioSTM32_Init(fs, sample_size);
    if (status != NO_ERROR)
    {
        return status;
    }

    return NO_ERROR;
}

static void send_when_ready(uint16_t data)
{
    while (SPI_I2S_GetFlagStatus(SPI2, SPI_FLAG_TXE) == RESET){}
    SPI_I2S_SendData(SPI2, data);
}

status_e Audio_PlaySin(uint16_t freq, uint16_t duration)
{
    timeout_t elapsed;
    struct sine_wave_state_t sine_state;

    init_sine_wave_float(&sine_state, 1.0, setup.fs, freq, 0);
    elapsed = time_set_timeout_ms(duration);

    switch (setup.byte_per_sample)
    {
    case 2:
        while (!time_elapsed(elapsed))
        {
            int16_t sample = (gen_sine_wave_float(&sine_state)*INT16_MAX/2);
            send_when_ready(sample);
            send_when_ready(sample);
        }
    break;
    case 3:
        while (!time_elapsed(elapsed))
        {
            int32_t sample = (gen_sine_wave_float(&sine_state)*INT32_MAX/2);
            sample >>=8;
            int32_t left = sample;
            int32_t right = sample;

            send_when_ready(left << 8);
            send_when_ready((left & 0xff) >> 8 | (right & 0xff) << 8);
            send_when_ready(right >> 8);
        }
    break;
    case 4:
        while (!time_elapsed(elapsed))
        {
            int32_t sample = (gen_sine_wave_float(&sine_state)*INT32_MAX/2);
            send_when_ready(sample >> 16);
            send_when_ready(sample);
            send_when_ready(sample >> 16);
            send_when_ready(sample);
        }
    break;
    }

    return NO_ERROR;
}

status_e Audio_Play(const int16_t *src, uint32_t length)
{
    return AudioSTM32_Play(src, length);
}

status_e Audio_Record(int16_t *dest, uint32_t length)
{
    return AudioSTM32_Record(dest, length);
}

status_e Audio_SetVolumeSpeaker(uint8_t volume)
{
    return AudioCodec_VolumeSpeaker(volume);
}

status_e Audio_SetVolumeHeadphone(uint8_t volume)
{
    return AudioCodec_VolumeHeadphone(volume);
}