example/pc_speaker/sound_api.c

   1
   2 /* usb device play sound api */
   3
   4 #include <mqx.h>
   5 #include <bsp.h>
   6 #include "pcm_lib.h"
   7
   8 #define DAC_CODEC     /* If the sample define DAC_CODEC to playback at dac then the pcm lib must define KINETS_K60DAC in soc_config.h and rebuild !  */
   9 struct snd_pcm_params  u_params;
  10
  11 void * pcm_handle = NULL;
  12
  13 /*
  14  * default set is the sample rate 44100, 16 bits, 2 channel
  15  * umute
  16  */
  17 int32_t snd_init(void)
  18 {
  19         _mem_zero((void *) &u_params, sizeof(u_params));
  20         u_params.access = SNDRV_PCM_ACCESS_INTERLEAVED;
  21         u_params.channels =  2;
  22         u_params.format = SNDRV_PCM_FORMAT_S16;
  23 #ifdef DAC_CODEC
  24         u_params.periods =  4;
  25         u_params.period_size  = 512;
  26 #else
  27         u_params.periods =  4 ;
  28         u_params.period_size  = 128;
  29 #endif
  30
  31         u_params.silence_size = /* u_params.period_size*/0;
  32         u_params.silence_threshold = THRESHOLD_BOUNDARY; /* THRESHOLD_BOUNDARY -> 0*/
  33         u_params.rate = 44100;
  34
  35         u_params.start_threshold = u_params.periods * u_params.period_size / 2;            /* start at the half of the buffer */
  36         u_params.stop_threshold = u_params.periods *  u_params.period_size;
  37
  38         if(pcm_stream_init(&pcm_handle,SNDRV_PCM_STREAM_PLAYBACK,&u_params)) {
  39                 printf(" pcm init failed\n");
  40                 return -1;
  41         }
  42
  43         printf("snd_init");
  44         return 0;
  45 }
  46
  47 #ifdef DAC_CODEC
  48 extern void dac_skew_sample_rate(int skew);
  49 #endif
  50
  51 /*
  52  * write samples to device
  53  * must have correct set before write
  54  */
  55 int32_t snd_write(uint8_t * pcmStream, uint32_t pcmCnt)
  56 {
  57 #ifdef DAC_CODEC
  58         int  avail_rate = snd_pcm_get_avail_rate (pcm_handle);
  59         int res = 100 - avail_rate;     /* residue */
  60
  61         if (avail_rate > 0) {      /* these get from ADK2012 */
  62                 static int lastres[2];
  63                 //if (res > (AUDBUFSIZE / 2)) {
  64                 if (res > (50)) {
  65                         // we're overrunning the dac, increase its sample rate
  66                         static int a = 0;
  67                         if (lastres[1] < lastres[0] && lastres[0] < res) {
  68                                 a++;
  69                                 if (a > 5) {
  70                                         int adj = res * 20 ;
  71                                         dac_skew_sample_rate(adj);
  72                                         //dbgPrintf("o%d +%d %d\n", res, adj, audsamplerate);
  73                                         a = 0;
  74                                 }
  75                         }
  76                 } else {
  77                         // we're underunning the dac, decrease its sample rate
  78                         static int a = 0;
  79
  80                         if (res == 1 || lastres[1] > lastres[0] && lastres[0] > res) {
  81                                 a++;
  82                                 if (a > 5) {
  83                                         int adj =  avail_rate * 20;
  84                                         dac_skew_sample_rate(-adj);
  85                                         //dbgPrintf("u%d -%d %d\n", res, adj, audsamplerate);
  86                                         a = 0;
  87                                 }
  88                         }
  89                 }
  90                 lastres[1] = lastres[0];
  91                 lastres[0] = res;
  92
  93         }
  94 #endif
  95         return u_audio_playback(pcm_handle, pcmStream, pcmCnt);
  96 }
  97
  98 int32_t snd_read(uint8_t * pcmStream, uint32_t pcmCnt)
  99 {
 100 #if 0
 101         ssize_t result;
 102         snd_pcm_sframes_t frames;
 103
 104         struct snd_pcm_runtime *runtime = (struct snd_pcm_runtime *)handle;
 105
 106         frames = bytes_to_frames(runtime, pcmCnt);
 107         result = snd_pcm_lib_read(runtime,pcmStream,frames,NON_BLOCK /* RW_BLOCK*/);
 108
 109         return result;
 110 #endif
 111         return 0;
 112 }
 113
 114 /*
 115  * collect resources of sound device
 116  */
 117 int32_t snd_deinit(void)
 118 {
 119         if (pcm_handle) {
 120                 printf("snd_deinit\n");
 121                 pcm_stream_deinit(pcm_handle);
 122                 pcm_handle = NULL;
 123         }
 124         else {
 125                 printf("denit pcm stream ,but handle is null\n");
 126         }
 127         return 0;
 128 }
 129
 130 /*
 131  * set pcm sound format: sample rate, bit width, channel number
 132  */
 133 int32_t snd_set_format(uint32_t sampleRate, uint8_t bitWidth, uint8_t chNum)
 134 {
 135         _mem_zero((void *) &u_params, sizeof(u_params));
 136
 137 #ifdef DAC_CODEC
 138         u_params.access = SNDRV_PCM_ACCESS_INTERLEAVED;//SNDRV_PCM_ACCESS_NONINTERLEAVED;
 139 #else
 140         u_params.access = SNDRV_PCM_ACCESS_INTERLEAVED;
 141 #endif
 142         u_params.channels =  2;
 143
 144         u_params.format = SNDRV_PCM_FORMAT_S16;
 145
 146         u_params.periods =  4;
 147         u_params.period_size  = 128;
 148
 149         u_params.silence_size =  u_params.period_size;
 150         //u_params.silence_size =   0 ;
 151         u_params.silence_threshold = THRESHOLD_BOUNDARY; /* THRESHOLD_BOUNDARY -> 0*/
 152         u_params.rate = 44100;
 153
 154         u_params.start_threshold = u_params.periods * u_params.period_size / 2;  /* start at the half of the buffer */
 155         u_params.stop_threshold = u_params.periods *  u_params.period_size;
 156
 157         switch (bitWidth)
 158         {
 159         case 16:
 160                 u_params.format = SNDRV_PCM_FORMAT_S16;
 161                 break;
 162         case 24:
 163                 u_params.format =   SNDRV_PCM_FORMAT_S24_3LE ;  /* SNDRV_PCM_FORMAT_S24 */
 164                 break;
 165         default:
 166                 printf("err:only support sample bits equal 16 or 24\n");
 167                 return -1;
 168         }
 169
 170         u_params.rate = sampleRate;
 171         if(sampleRate > 48000) {
 172                 u_params.periods = 4;
 173                 u_params.period_size  = 256;
 174                 //u_params.silence_size =  u_params.period_size;
 175                 u_params.silence_size =   0 ;
 176         }
 177         else {
 178 #ifdef DAC_CODEC
 179                 u_params.periods =  4;
 180                 u_params.period_size  = 512;
 181 #else
 182                 u_params.periods =  4;
 183                 u_params.period_size  = 128;
 184 #endif
 185 #ifdef DAC_CODEC
 186                 u_params.silence_size = 0;
 187 #else
 188                 u_params.silence_size =   u_params.period_size ;
 189 #endif
 190         }
 191
 192         /* start at the half of the buffer */
 193         u_params.start_threshold = u_params.periods * u_params.period_size / 2;
 194         u_params.stop_threshold = u_params.periods *  u_params.period_size;
 195
 196         if (pcm_handle) {
 197                 pcm_stream_deinit(pcm_handle);
 198                 pcm_handle = NULL;
 199         }
 200         _time_delay(1);
 201         if(pcm_stream_init(&pcm_handle,SNDRV_PCM_STREAM_PLAYBACK,&u_params)) {
 202                 printf(" set params failed\n");
 203                 return -1;
 204         }
 205         /*
 206         int snd_pcm_params(void * handle,
 207                              struct snd_pcm_params *params) */
 208
 209         return 0;
 210 }
 211
 212 /*
 213  * turn up sound volume
 214  */
 215 int32_t snd_vol_up(void)
 216 {
 217         // todo
 218         return 0;
 219 }
 220
 221 /*
 222  * turn down sound volume
 223  */
 224 int32_t snd_vol_down(void)
 225 {
 226         // todo
 227         return  0;
 228 }
 229
 230 /*
 231  * mute sound device
 232  */
 233 int32_t snd_mute(void)
 234 {
 235         // todo
 236         return 0;
 237 }
 238 /*
 239  * umute device
 240  */
 241 int32_t snd_umute(void)
 242 {
 243         // todo
 244         return 0;
 245 }
 246
 247 /*
 248  * flush the pcm stream out
 249  *
 250  */
 251 int32_t snd_flush(void)
 252 {
 253         // todo
 254         return 0;
 255 }