AudioPlayer.c

Go to the documentation of this file.

/*
 * AudioPlayer.c
 *
 *  Created on: May 28, 2016
 *      Author: Torsten
 */

/* Includes ------------------------------------------------------------------*/
#include "AudioPlayer.h"

extern SemaphoreHandle_t xSemaphoreAudio;

/* Private define ------------------------------------------------------------*/

/* Private macro -------------------------------------------------------------*/
/* Private typedef -----------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
static AUDIO_OUT_BufferTypeDef  BufferCtl;
static unsigned long sAudioHeartbeat = 0;

/* Private function prototypes -----------------------------------------------*/

/* Private functions ---------------------------------------------------------*/

int AUDIO_PLAYER_GetClock(void)
{
#if 0
    if (BufferCtl.clockState)
    {
        BufferCtl.clockState = 0;
        return 1;
    }
    else
        return 0;
#else
    //we will block here for max. 200 msec if we do not have an audio clock, so the GUI remains a bit responsive
    if (xSemaphoreTake(xSemaphoreAudio, 200) == pdTRUE)
    {
        BufferCtl.clockState = 0;
        return 1;
    }
    else
    {
        taskYIELD();
        return 0;
    }
#endif
}

void AUDIO_PLAYER_ReleaseClock(int trig)
{
    static BaseType_t xHigherPriorityTaskWoken;

    //called from ISR - INT should be disabled !
    BufferCtl.clockState = trig;

    xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xSemaphoreAudio, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

int AUDIO_PLAYER_GetState(void)
{
    if (BufferCtl.state == BUFFER_OFFSET_HALF)
        return 0;
    else
        return 1;
}

int AUDIO_PLAYER_GetBuffer(uint8_t **out_BufAddr)
{
    *out_BufAddr = BufferCtl.buff;
    return sizeof(BufferCtl.buff);
}

AUDIO_ErrorTypeDef AUDIO_PLAYER_Init(int outSelection, int sampleFreq)
{
  if (outSelection)
  {
      if(BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_HEADPHONE, 100, sampleFreq) == 0)
      {
          BSP_AUDIO_OUT_SetAudioFrameSlot(CODEC_AUDIOFRAME_SLOT_02);
          return AUDIO_ERROR_NONE;
      }
      else
      {
          return AUDIO_ERROR_IO;
      }
  }
  else
  {
      if(BSP_AUDIO_OUT_Init(OUTPUT_DEVICE_SPEAKER, 100, sampleFreq) == 0)
      {
          BSP_AUDIO_OUT_SetAudioFrameSlot(CODEC_AUDIOFRAME_SLOT_13);
          return AUDIO_ERROR_NONE;
      }
      else
      {
          return AUDIO_ERROR_IO;
      }
  }
}

AUDIO_ErrorTypeDef AUDIO_PLAYER_Start(void)
{
    BSP_AUDIO_OUT_Play((uint16_t*)&BufferCtl.buff[0], AUDIO_OUT_BUFFER_SIZE);
    BufferCtl.clockState = 0;
    return AUDIO_ERROR_NONE;
}

void AUDIO_PLAYER_Restart(void)
{
    BSP_AUDIO_OUT_Restart((uint16_t*)&BufferCtl.buff[0], AUDIO_OUT_BUFFER_SIZE);
    BufferCtl.clockState = 0;
    BufferCtl.state = 0;
}

AUDIO_ErrorTypeDef AUDIO_PLAYER_Process(void)
{
  return AUDIO_ERROR_NONE;
}

AUDIO_ErrorTypeDef AUDIO_PLAYER_Stop(void)
{
  BSP_AUDIO_OUT_Stop(CODEC_PDWN_SW);
  return AUDIO_ERROR_NONE;
}

#if 1

void BSP_AUDIO_OUT_TransferComplete_CallBack(void)
{
    BufferCtl.state = BUFFER_OFFSET_FULL;
    //BufferCtl.clockState = 2;
    AUDIO_PLAYER_ReleaseClock(2);
}

void BSP_AUDIO_OUT_HalfTransfer_CallBack(void)
{
    BufferCtl.state = BUFFER_OFFSET_HALF;
    //BufferCtl.clockState = 1;
    AUDIO_PLAYER_ReleaseClock(1);
}
#endif

void AUDIO_Player_CpyBuf(uint8_t *buf)
{
    if (BufferCtl.state == BUFFER_OFFSET_FULL)
        memcpy(&BufferCtl.buff[AUDIO_TOTAL_BUF_SIZE], buf, AUDIO_TOTAL_BUF_SIZE);
    else
        memcpy(&BufferCtl.buff[0], buf, AUDIO_TOTAL_BUF_SIZE);

    AUDIO_Player_IncHeartbeat();
}

static int initDone = 0;
static int oIdx = 0;

#if 0
void AUDIO_Player_QueueBuf(uint8_t *buf, int len)
{
    uint8_t *dbuf;
    static int oIdx = 0;
    static int oState = 0;

    if (oState < 3)
    {
    if (BufferCtl.state == BUFFER_OFFSET_FULL)
        //second buffer
        if ( ! oState)
            oState = 2;
        else
            oState = 4;
    else
        //first buffer
        if ( ! oState)
            oState = 1;
        else
            oState = 3;
    }

    //wait for a new edge on DMA trigger, to make sure to start properly
    if (oState < 3)
        return;

    if (oState == 4)
    {
        dbuf = &BufferCtl.buff[AUDIO_TOTAL_BUF_SIZE];
    }
    else
    {
        dbuf = &BufferCtl.buff[0];
    }

    if (oIdx <= (AUDIO_TOTAL_BUF_SIZE - len))
    {
        memcpy(dbuf + oIdx, buf, len);
        oIdx += len;
    }
    else
    {
        //ERROR: what to do now?
        oIdx = AUDIO_TOTAL_BUF_SIZE;
    }

    if (oIdx >= AUDIO_TOTAL_BUF_SIZE)
    {
        oIdx = 0;
        //flip the state for which buffer
        if (oState == 4)
            oState = 3;
        else
            oState = 4;
    }
}
#else
void AUDIO_Player_QueueBuf(uint8_t *buf, int len)
{
    //just to make sure:
    if ((oIdx + len) <= sizeof(BufferCtl.buff))
    {
        memcpy(&BufferCtl.buff[oIdx], buf, len);
        oIdx += len;
    }
    else
    {
        //an error, what to do?
        oIdx = 0;
        return;
    }

    if ( ! initDone)
    {
        //tricky: how to restart audio out so that it is in sync?
        //this seems to work the best way, but not always, we need a new reset and restart
        if (oIdx >= (sizeof(BufferCtl.buff) / 2 + 192))
        {
            AUDIO_PLAYER_Restart();
            initDone = 1;
        }
    }

    if (oIdx >= sizeof(BufferCtl.buff))
        oIdx = 0;

    AUDIO_Player_IncHeartbeat();
}
#endif

void AUDIO_Player_UDANTERestart(void)
{
    initDone = 0;
    oIdx = 0;
}

unsigned long AUDIO_Player_GetHeartbeat(void)
{
    unsigned long x;
    x = sAudioHeartbeat;
    sAudioHeartbeat = 0;

    //if no heartbeat - clear the buffer
    if ( ! x)
        memset(BufferCtl.buff, 0x00, sizeof(BufferCtl.buff));

    return x;
}

void AUDIO_Player_IncHeartbeat(void)
{
    sAudioHeartbeat++;
}

/*******************************************************************************
                            Static Functions
*******************************************************************************/

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/