Audio.h

Go to the documentation of this file.

/*
 *  Audio.h - Audio include file for the Spresense SDK
 *  Copyright 2018 Sony Semiconductor Solutions Corporation
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef Audio_h
#define Audio_h
 
#ifdef SUBCORE
#error "Audio library is NOT supported by SubCore."
#endif
 
#include <pins_arduino.h>
 
class File;
 
// #ifdef __cplusplus
 
#include <audio/audio_high_level_api.h>
#include <audio/utilities/wav_containerformat.h>
#include <audio/utilities/wav_containerformat_parser.h>
#include <audio/utilities/frame_samples.h>
#include <memutils/simple_fifo/CMN_SimpleFifo.h>
 
#define WRITE_FIFO_FRAME_NUM  (8)
#define WRITE_FIFO_FRAME_SIZE (1024*2*3)
#define WRITE_BUF_SIZE   (WRITE_FIFO_FRAME_NUM * WRITE_FIFO_FRAME_SIZE)
 
#define READ_FIFO_FRAME_NUM   (10)
#define READ_FIFO_FRAME_SIZE  (1024*2*8)
#define READ_BUF_SIZE    (READ_FIFO_FRAME_NUM * READ_FIFO_FRAME_SIZE)
 
#define FIFO_FRAME_SIZE (\
                          (WRITE_BUF_SIZE > READ_BUF_SIZE) ?\
                          (WRITE_FIFO_FRAME_SIZE) : (READ_FIFO_FRAME_SIZE)\
                        )
 
#define SIMPLE_FIFO_BUF_SIZE (\
                               ((WRITE_BUF_SIZE) > (READ_BUF_SIZE)) ? \
                               (WRITE_BUF_SIZE) : (READ_BUF_SIZE)\
                             )
 
extern "C" void  outputDeviceCallback(uint32_t);
 
/*--------------------------------------------------------------------------*/
#define print_err printf
 
#ifdef BRD_DEBUG
#define print_dbg(...) printf(__VA_ARGS__)
#else
#define print_dbg(x...)
#endif
 
/*--------------------------------------------------------------------------*/
 
#define AS_CODECTYPE_PCM  5
 
/*--------------------------------------------------------------------------*/
#define AUDIOLIB_ECODE_OK                  0  
#define AUDIOLIB_ECODE_SHARED_MEMORY_ERROR 1  
#define AUDIOLIB_ECODE_SIMPLEFIFO_ERROR    2  
#define AUDIOLIB_ECODE_AUDIOCOMMAND_ERROR  3  
#define AUDIOLIB_ECODE_FILEACCESS_ERROR    4  
#define AUDIOLIB_ECODE_FILEEND             5  
#define AUDIOLIB_ECODE_BUFFER_AREA_ERROR   6  
#define AUDIOLIB_ECODE_BUFFER_SIZE_ERROR   7  
#define AUDIOLIB_ECODE_INSUFFICIENT_BUFFER_AREA   8  
#define AUDIOLIB_ECODE_WAV_PARSE_ERROR     9  
#define AUDIOLIB_ECODE_PARAMETER_ERROR    10  
/*--------------------------------------------------------------------------*/
typedef unsigned int err_t;
 
/*--------------------------------------------------------------------------*/
 
class AudioClass
{
public:
 
  static AudioClass* getInstance()
    {
      static AudioClass instance;
      return &instance;
    }
 
  typedef enum
  {
    Player0,  
    Player1   
  } PlayerId;
 
  err_t begin(void);
 
  err_t begin(AudioAttentionCb attcb);
 
  err_t end(void);
 
  err_t setPlayerMode(
      uint8_t device  
  );
 
  err_t setPlayerMode(
      uint8_t device,          
      uint32_t player0bufsize, 
      uint32_t player1bufsize  
  );
 
  err_t setPlayerMode(
      uint8_t device, 
      uint8_t sp_drv 
  );
 
  err_t setPlayerMode(
      uint8_t device,          
      uint8_t sp_drv,          
      uint32_t player0bufsize, 
      uint32_t player1bufsize  
  );
 
  err_t setRecorderMode(
      uint8_t input_device 
  );
 
  err_t setRecorderMode(
      uint8_t input_device, 
      int32_t input_gain    
  );
 
  err_t setRecorderMode(
      uint8_t input_device, 
      int32_t input_gain,   
      uint32_t bufsize      
  );
 
  err_t setRecorderMode(
      uint8_t input_device, 
      int32_t input_gain,   
      uint32_t bufsize,     
      bool is_digital       
  );
 
  typedef enum
  {
    MicIn,  
    I2sIn,  
    BothIn  
  } ThroughInput;
 
  typedef enum
  {
    None,   
    Mixer,  
    Mic     
  } ThroughI2sOut;
 
  err_t setThroughMode(
      ThroughInput input,     
      ThroughI2sOut i2s_out,  
      bool sp_out,            
      int32_t input_gain,     
      uint8_t sp_drv 
  );
 
  err_t setReadyMode(void);
 
  err_t initPlayer(
      PlayerId id,    
      uint8_t codec,  
      uint32_t fs,    
      uint8_t channel 
  );
 
  err_t initPlayer(
      PlayerId id,    
      uint8_t codec,  
      uint32_t fs,    
      uint8_t bitlen, 
      uint8_t channel 
  );
 
  err_t initPlayer(
      PlayerId id,    
      uint8_t codec,  
      const char *codec_path,  
      uint32_t fs,    
      uint8_t channel 
  );
 
  err_t initPlayer(
      PlayerId id,    
      uint8_t codec,  
      const char *codec_path,  
      uint32_t fs,    
      uint8_t bitlen, 
      uint8_t channel 
  );
 
  err_t initRecorder(
      uint8_t codec,  
      uint32_t fs,    
      uint8_t channel 
  );
 
  err_t initRecorder(
      uint8_t codec,  
      uint32_t fs,    
      uint8_t bitlen, 
      uint8_t channel 
  );
 
  err_t initRecorder(
      uint8_t codec,  
      const char *codec_path, 
      uint32_t fs,    
      uint8_t channel 
  );
 
  err_t initRecorder(
      uint8_t codec,  
      const char *codec_path, 
      uint32_t fs,    
      uint8_t bitlen, 
      uint8_t channel 
  );
 
  err_t startPlayer(
      PlayerId id    
  );
 
  err_t startRecorder(void);
 
  err_t stopPlayer(
      PlayerId id 
  );
 
  err_t stopPlayer(
      PlayerId id, 
      uint8_t mode 
  );
 
  err_t stopRecorder(void);
 
  err_t setBeep(
      char  enable, 
      short volume, 
      short frequency 
  );
 
  err_t setVolume(
      int volume 
  );
 
  err_t setVolume(
      int master,  
      int player0, 
      int player1  
  );
 
  err_t setLRgain(
      PlayerId id,          
      unsigned char l_gain, 
      unsigned char r_gain  
  );
 
  err_t writeFrames(
      PlayerId id, 
      File& myfile 
  );
 
  err_t writeFrames(
      PlayerId id, 
      int fd       
  );
 
  err_t writeFrames(
      PlayerId id,        
      uint8_t *data,      
      uint32_t write_size 
  );
 
  err_t writeWavHeader(
      File& myFile
  );
 
  err_t readFrames(
      File& myFile
  );
 
  err_t closeOutputFile(
      File& myFile
  );
 
 
  err_t readFrames(
      char*     p_buffer,    
      uint32_t  buffer_size, 
      uint32_t* read_size    
  );
 
  err_t setRenderingClockMode(
      AsClkMode mode 
  );
 
   int getRecordingSize() {
     return m_es_size;
   }
 
private:
 
  AudioClass()
    : m_player0_simple_fifo_buf(NULL)
    , m_player1_simple_fifo_buf(NULL)
    , m_attention_callback(NULL)
  {}
  AudioClass(const AudioClass&);
  AudioClass& operator=(const AudioClass&);
  ~AudioClass() {}
 
  char m_es_player0_buf[FIFO_FRAME_SIZE];
  char m_es_player1_buf[WRITE_FIFO_FRAME_SIZE];
 
  CMN_SimpleFifoHandle m_player0_simple_fifo_handle;
  CMN_SimpleFifoHandle m_player1_simple_fifo_handle;
  uint32_t *m_player0_simple_fifo_buf;
  uint32_t *m_player1_simple_fifo_buf;
 
  AsPlayerInputDeviceHdlrForRAM m_player0_input_device_handler;
  AsPlayerInputDeviceHdlrForRAM m_player1_input_device_handler;
 
  AsRecorderOutputDeviceHdlr    m_output_device_handler;
  int                           m_es_size;
  WAVHEADER                     m_wav_format;
  int                           m_codec_type;
 
  AudioAttentionCb m_attention_callback;
 
  /* Private Functions */
 
  /* Functions for initialization on begin/end */
  err_t begin_manager(void);
  err_t begin_player(void);
  err_t begin_recorder(void);
 
  err_t end_manager(void);
  err_t end_player(void);
  err_t end_recorder(void);
 
  err_t activateAudio(void);
 
  err_t powerOn(void);
  err_t powerOff(void);
 
  /* Functions for initialization Encoder */
  
  err_t initMicFrontend(uint8_t ch_num, uint8_t bit_length, uint16_t sample);
  err_t init_recorder_wav(AudioCommand* command, uint32_t sampling_rate, uint8_t bit_length, uint8_t channel_number);
  err_t init_recorder_mp3(AudioCommand* command, uint32_t sampling_rate, uint8_t bit_length, uint8_t channel_number);
  err_t init_recorder_opus(AudioCommand* command, uint32_t sampling_rate, uint8_t bit_length, uint8_t channel_number);
  err_t init_recorder_pcm(AudioCommand* command, uint32_t sampling_rate, uint8_t bit_length, uint8_t channel_number);
 
  /* Functions for initialization on player mode. */
  err_t set_output(uint8_t device, uint8_t sp_drv);
 
  err_t write_fifo(int, char*, uint32_t, CMN_SimpleFifoHandle*);
  err_t write_fifo(File&, char*, uint32_t, CMN_SimpleFifoHandle*);
 
  /* Functions for initialization on recorder mode. */
  err_t set_mic_map(uint8_t map[AS_MIC_CHANNEL_MAX]);
  err_t init_mic_gain(int, int);
 
  /* Functions for initialization on through mode. */
  err_t send_set_through(void);
 
  bool check_decode_dsp(uint8_t codec_type, const char *path);
  bool check_encode_dsp(uint8_t codec_type, const char *path, uint32_t fs);
};
 
extern AudioClass Audio;
 
// #endif //__cplusplus
#endif //Audio_h