/*!
    \file    audio_out_itf.c
    \brief   audio OUT (playback) interface functions

    \version 2020-08-01, V3.0.0, firmware for GD32F30x
*/

/*
    Copyright (c) 2020, GigaDevice Semiconductor Inc.

    Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

    1. Redistributions of source code must retain the above copyright notice, this
       list of conditions and the following disclaimer.
    2. Redistributions in binary form must reproduce the above copyright notice,
       this list of conditions and the following disclaimer in the documentation
       and/or other materials provided with the distribution.
    3. Neither the name of the copyright holder nor the names of its contributors
       may be used to endorse or promote products derived from this software without
       specific prior written permission.

    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/

#include "audio_core.h"
#include "audio_out_itf.h"

/* local function prototypes ('static') */
static uint8_t init         (uint32_t audio_freq, uint32_t volume, uint32_t options);
static uint8_t deinit       (uint32_t options);
static uint8_t audio_cmd    (uint8_t* pbuf, uint32_t size, uint8_t cmd);
static uint8_t volume_ctl   (uint8_t vol);
static uint8_t mute_ctl     (uint8_t cmd);
static uint8_t periodic_tc  (uint8_t cmd);
static uint8_t get_state    (void);

audio_fops_struct audio_out_fops =
{
    init,
    deinit,
    audio_cmd,
    volume_ctl,
    mute_ctl,
    periodic_tc,
    get_state
};

static uint8_t audio_state = AUDIO_STATE_INACTIVE;

/*!
    \brief      initialize and configures all required resources for audio play function
    \param[in]  audio_freq: statrt_up audio frequency
    \param[in]  volume: start_up volume to be set
    \param[in]  options: specific options passed to low layer function
    \param[out] none
    \retval     AUDIO_OK if all operations succeed, otherwise, AUDIO_FAIL.
*/
static uint8_t init (uint32_t audio_freq, uint32_t volume, uint32_t options)
{
    static uint32_t initialized = 0U;

    /* check if the low layer has already been initialized */
    if (0U == initialized) {
        /* call low layer function */
        if (0U != eval_audio_init(OUTPUT_DEVICE_AUTO, volume, audio_freq)) {
            audio_state = AUDIO_STATE_ERROR;

            return AUDIO_FAIL;
        }

        /* set the initialization flag to prevent reinitializing the interface again */
        initialized = 1U;
    }

    /* update the audio state machine */
    audio_state = AUDIO_STATE_ACTIVE;

    return AUDIO_OK;
}

/*!
    \brief      free all resources used by low layer and stops audio-play function
    \param[in]  options: specific options passed to low layer function
    \param[out] none
    \retval     AUDIO_OK if all operations succeed, otherwise, AUDIO_FAIL.
*/
static uint8_t deinit (uint32_t options)
{
    /* update the audio state machine */
    audio_state = AUDIO_STATE_INACTIVE;

    return AUDIO_OK;
}

/*!
    \brief      play, stop, pause or resume current file
    \param[in]  pbuf: address from which file should be played
    \param[in]  size: size of the current buffer/file
    \param[in]  cmd: command to be executed, can be:
      \arg        AUDIO_CMD_PLAY
      \arg        AUDIO_CMD_PAUSE
      \arg        AUDIO_CMD_RESUME
      \arg        AUDIO_CMD_STOP
    \param[out] none
    \retval     AUDIO_OK if all operations succeed, otherwise, AUDIO_FAIL.
*/
static uint8_t audio_cmd (uint8_t* pbuf, uint32_t size, uint8_t cmd)
{
    uint8_t status = AUDIO_OK;

    /* check the current state */
    if ((AUDIO_STATE_INACTIVE == audio_state) || (AUDIO_STATE_ERROR == audio_state)) {
        audio_state = AUDIO_STATE_ERROR;

        return AUDIO_FAIL;
    }

    switch (cmd) {
        /* process the play command */
        case AUDIO_CMD_PLAY:
            /* if current state is active or stopped */
            if ((AUDIO_STATE_ACTIVE == audio_state) || \
                (AUDIO_STATE_STOPPED == audio_state) || \
                (AUDIO_STATE_PLAYING == audio_state)) {
                audio_mal_play((uint32_t)pbuf, (size / 2U));
                audio_state = AUDIO_STATE_PLAYING;
            } else if (AUDIO_STATE_PAUSED == audio_state) {
                if (eval_audio_pause_resume(AUDIO_RESUME, (uint32_t)pbuf, (size / 2U))) {
                    audio_state = AUDIO_STATE_ERROR;

                    status = AUDIO_FAIL;
                } else {
                    audio_state = AUDIO_STATE_PLAYING;
                }
            } else {
                status = AUDIO_FAIL;
            }
            break;

        /* process the stop command */
        case AUDIO_CMD_STOP:
            if (AUDIO_STATE_PLAYING != audio_state) {
                /* unsupported command */
                status = AUDIO_FAIL;
            } else if (eval_audio_stop(CODEC_PDWN_SW)) {
                audio_state = AUDIO_STATE_ERROR;

                status = AUDIO_FAIL;
            } else {
                audio_state = AUDIO_STATE_STOPPED;
            }
            break;

        /* process the pause command */
        case AUDIO_CMD_PAUSE:
            if (AUDIO_STATE_PLAYING != audio_state) {
                /* unsupported command */
                status = AUDIO_FAIL;
            } else if (eval_audio_pause_resume(AUDIO_PAUSE, (uint32_t)pbuf, (size / 2U))) {
                audio_state = AUDIO_STATE_ERROR;

                status = AUDIO_FAIL;
            } else {
                audio_state = AUDIO_STATE_PAUSED;
            }
            break;

        /* unsupported command */
        default:
            break;
    }

    return status;
}

/*!
    \brief      set the volume level
    \param[in]  vol: volume level to be set in % (from 0% to 100%)
    \param[out] none
    \retval     AUDIO_OK if all operations succeed, otherwise, AUDIO_FAIL.
*/
static uint8_t volume_ctl (uint8_t vol)
{
    /* call low layer volume setting function */
    if (eval_audio_volume_ctl(vol)) {
        audio_state = AUDIO_STATE_ERROR;

        return AUDIO_FAIL;
    }

    return AUDIO_OK;
}

/*!
    \brief      mute or unmute the audio current output
    \param[in]  cmd: can be 0 to unmute, or 1 to mute
    \param[out] none
    \retval     AUDIO_OK if all operations succeed, otherwise, AUDIO_FAIL.
*/
static uint8_t mute_ctl (uint8_t cmd)
{
    /* call low layer mute setting function */
    if (eval_audio_mute((uint32_t)cmd)) {
        audio_state = AUDIO_STATE_ERROR;

        return AUDIO_FAIL;
    }

    return AUDIO_OK;
}

/*!
    \brief      periodic transfer control
    \param[in]  cmd: command
    \param[out] none
    \retval     AUDIO_OK if all operations succeed, otherwise, AUDIO_FAIL.
*/
static uint8_t periodic_tc (uint8_t cmd)
{
    return AUDIO_OK;
}

/*!
    \brief      return the current state of the audio machine
    \param[in]  none
    \param[out] none
    \retval     AUDIO_OK if all operations succeed, otherwise, AUDIO_FAIL.
*/
static uint8_t get_state (void)
{
    return audio_state;
}
