firmware/target/hosted/sdl/pcm-sdl.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Nick Lanham
  11  * Copyright (C) 2010 by Thomas Martitz
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License
  15  * as published by the Free Software Foundation; either version 2
  16  * of the License, or (at your option) any later version.
  17  *
  18  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  19  * KIND, either express or implied.
  20  *
  21  ****************************************************************************/
  22
  23 #include "autoconf.h"
  24
  25 #include <stdlib.h>
  26 #include <stdbool.h>
  27 #include <SDL.h>
  28 #include "config.h"
  29 #include "debug.h"
  30 #include "sound.h"
  31 #include "audiohw.h"
  32 #include "system.h"
  33
  34 #ifdef HAVE_RECORDING
  35 #include "audiohw.h"
  36 #ifdef HAVE_SPDIF_IN
  37 #include "spdif.h"
  38 #endif
  39 #endif
  40
  41 #include "pcm.h"
  42 #include "pcm_sampr.h"
  43
  44 /*#define LOGF_ENABLE*/
  45 #include "logf.h"
  46
  47 #ifdef DEBUG
  48 #include <stdio.h>
  49 extern bool debug_audio;
  50 #endif
  51
  52 static int sim_volume = 0;
  53
  54 #if CONFIG_CODEC == SWCODEC
  55 static int cvt_status = -1;
  56
  57 static Uint8* pcm_data;
  58 static size_t pcm_data_size;
  59 static size_t pcm_sample_bytes;
  60 static size_t pcm_channel_bytes;
  61
  62 static struct pcm_udata
  63 {
  64     Uint8 *stream;
  65     Uint32 num_in;
  66     Uint32 num_out;
  67 #ifdef DEBUG
  68     FILE  *debug;
  69 #endif
  70 } udata;
  71
  72 static SDL_AudioSpec obtained;
  73 static SDL_AudioCVT cvt;
  74
  75 void pcm_play_lock(void)
  76 {
  77     SDL_LockAudio();
  78 }
  79
  80 void pcm_play_unlock(void)
  81 {
  82     SDL_UnlockAudio();
  83 }
  84
  85 static void pcm_dma_apply_settings_nolock(void)
  86 {
  87     cvt_status = SDL_BuildAudioCVT(&cvt, AUDIO_S16SYS, 2, pcm_sampr,
  88                     obtained.format, obtained.channels, obtained.freq);
  89
  90     if (cvt_status < 0) {
  91         cvt.len_ratio = (double)obtained.freq / (double)pcm_sampr;
  92     }
  93 }
  94
  95 void pcm_dma_apply_settings(void)
  96 {
  97     pcm_play_lock();
  98     pcm_dma_apply_settings_nolock();
  99     pcm_play_unlock();
 100 }
 101
 102 void pcm_play_dma_start(const void *addr, size_t size)
 103 {
 104     pcm_dma_apply_settings_nolock();
 105
 106     pcm_data = (Uint8 *) addr;
 107     pcm_data_size = size;
 108
 109     SDL_PauseAudio(0);
 110 }
 111
 112 void pcm_play_dma_stop(void)
 113 {
 114     SDL_PauseAudio(1);
 115 #ifdef DEBUG
 116     if (udata.debug != NULL) {
 117         fclose(udata.debug);
 118         udata.debug = NULL;
 119         DEBUGF("Audio debug file closed\n");
 120     }
 121 #endif
 122 }
 123
 124 void pcm_play_dma_pause(bool pause)
 125 {
 126     if (pause)
 127         SDL_PauseAudio(1);
 128     else
 129         SDL_PauseAudio(0);
 130 }
 131
 132 size_t pcm_get_bytes_waiting(void)
 133 {
 134     return pcm_data_size;
 135 }
 136
 137 static void write_to_soundcard(struct pcm_udata *udata)
 138 {
 139 #ifdef DEBUG
 140     if (debug_audio && (udata->debug == NULL)) {
 141         udata->debug = fopen("audiodebug.raw", "ab");
 142         DEBUGF("Audio debug file open\n");
 143     }
 144 #endif
 145     if (cvt.needed) {
 146         Uint32 rd = udata->num_in;
 147         Uint32 wr = (double)rd * cvt.len_ratio;
 148
 149         if (wr > udata->num_out) {
 150             wr = udata->num_out;
 151             rd = (double)wr / cvt.len_ratio;
 152
 153             if (rd > udata->num_in)
 154             {
 155                 rd = udata->num_in;
 156                 wr = (double)rd * cvt.len_ratio;
 157             }
 158         }
 159
 160         if (wr == 0 || rd == 0)
 161         {
 162             udata->num_out = udata->num_in = 0;
 163             return;
 164         }
 165
 166         if (cvt_status > 0) {
 167             cvt.len = rd * pcm_sample_bytes;
 168             cvt.buf = (Uint8 *) malloc(cvt.len * cvt.len_mult);
 169
 170             memcpy(cvt.buf, pcm_data, cvt.len);
 171
 172             SDL_ConvertAudio(&cvt);
 173             SDL_MixAudio(udata->stream, cvt.buf, cvt.len_cvt, sim_volume);
 174
 175             udata->num_in = cvt.len / pcm_sample_bytes;
 176             udata->num_out = cvt.len_cvt / pcm_sample_bytes;
 177
 178 #ifdef DEBUG
 179             if (udata->debug != NULL) {
 180                fwrite(cvt.buf, sizeof(Uint8), cvt.len_cvt, udata->debug);
 181             }
 182 #endif
 183             free(cvt.buf);
 184         }
 185         else {
 186             /* Convert is bad, so do silence */
 187             Uint32 num = wr*obtained.channels;
 188             udata->num_in = rd;
 189             udata->num_out = wr;
 190
 191             switch (pcm_channel_bytes)
 192             {
 193             case 1:
 194             {
 195                 Uint8 *stream = udata->stream;
 196                 while (num-- > 0)
 197                     *stream++ = obtained.silence;
 198                 break;
 199                 }
 200             case 2:
 201             {
 202                 Uint16 *stream = (Uint16 *)udata->stream;
 203                 while (num-- > 0)
 204                     *stream++ = obtained.silence;
 205                 break;
 206                 }
 207             }
 208 #ifdef DEBUG
 209             if (udata->debug != NULL) {
 210                fwrite(udata->stream, sizeof(Uint8), wr, udata->debug);
 211             }
 212 #endif
 213         }
 214     } else {
 215         udata->num_in = udata->num_out = MIN(udata->num_in, udata->num_out);
 216         SDL_MixAudio(udata->stream, pcm_data,
 217                      udata->num_out * pcm_sample_bytes, sim_volume);
 218 #ifdef DEBUG
 219         if (udata->debug != NULL) {
 220            fwrite(pcm_data, sizeof(Uint8), udata->num_out * pcm_sample_bytes,
 221                   udata->debug);
 222         }
 223 #endif
 224     }
 225 }
 226
 227 static void sdl_audio_callback(struct pcm_udata *udata, Uint8 *stream, int len)
 228 {
 229     logf("sdl_audio_callback: len %d, pcm %d\n", len, pcm_data_size);
 230     udata->stream = stream;
 231
 232     /* Write what we have in the PCM buffer */
 233     if (pcm_data_size > 0)
 234         goto start;
 235
 236     /* Audio card wants more? Get some more then. */
 237     while (len > 0) {
 238         pcm_play_get_more_callback((void **)&pcm_data, &pcm_data_size);
 239     start:
 240         if (pcm_data_size != 0) {
 241             udata->num_in  = pcm_data_size / pcm_sample_bytes;
 242             udata->num_out = len / pcm_sample_bytes;
 243
 244             write_to_soundcard(udata);
 245
 246             udata->num_in  *= pcm_sample_bytes;
 247             udata->num_out *= pcm_sample_bytes;
 248
 249             pcm_data      += udata->num_in;
 250             pcm_data_size -= udata->num_in;
 251             udata->stream += udata->num_out;
 252             len           -= udata->num_out;
 253         } else {
 254             DEBUGF("sdl_audio_callback: No Data.\n");
 255             break;
 256         }
 257     }
 258 }
 259
 260 const void * pcm_play_dma_get_peak_buffer(int *count)
 261 {
 262     uintptr_t addr = (uintptr_t)pcm_data;
 263     *count = pcm_data_size / 4;
 264     return (void *)((addr + 2) & ~3);
 265 }
 266
 267 #ifdef HAVE_RECORDING
 268 void pcm_rec_lock(void)
 269 {
 270 }
 271
 272 void pcm_rec_unlock(void)
 273 {
 274 }
 275
 276 void pcm_rec_dma_init(void)
 277 {
 278 }
 279
 280 void pcm_rec_dma_close(void)
 281 {
 282 }
 283
 284 void pcm_rec_dma_start(void *start, size_t size)
 285 {
 286     (void)start;
 287     (void)size;
 288 }
 289
 290 void pcm_rec_dma_stop(void)
 291 {
 292 }
 293
 294 const void * pcm_rec_dma_get_peak_buffer(void)
 295 {
 296     return NULL;
 297 }
 298
 299 void audiohw_set_recvol(int left, int right, int type)
 300 {
 301     (void)left;
 302     (void)right;
 303     (void)type;
 304 }
 305
 306 #ifdef HAVE_SPDIF_IN
 307 unsigned long spdif_measure_frequency(void)
 308 {
 309     return 0;
 310 }
 311 #endif
 312
 313 #endif /* HAVE_RECORDING */
 314
 315 void pcm_play_dma_init(void)
 316 {
 317     if (SDL_InitSubSystem(SDL_INIT_AUDIO))
 318     {
 319         DEBUGF("Could not initialize SDL audio subsystem!\n");
 320         return;
 321     }
 322
 323     SDL_AudioSpec wanted_spec;
 324 #ifdef DEBUG
 325     udata.debug = NULL;
 326     if (debug_audio) {
 327         udata.debug = fopen("audiodebug.raw", "wb");
 328         DEBUGF("Audio debug file open\n");
 329     }
 330 #endif
 331     /* Set 16-bit stereo audio at 44Khz */
 332     wanted_spec.freq = 44100;
 333     wanted_spec.format = AUDIO_S16SYS;
 334     wanted_spec.channels = 2;
 335     wanted_spec.samples = 2048;
 336     wanted_spec.callback =
 337         (void (SDLCALL *)(void *userdata,
 338             Uint8 *stream, int len))sdl_audio_callback;
 339     wanted_spec.userdata = &udata;
 340
 341     /* Open the audio device and start playing sound! */
 342     if(SDL_OpenAudio(&wanted_spec, &obtained) < 0) {
 343         DEBUGF("Unable to open audio: %s\n", SDL_GetError());
 344         return;
 345     }
 346
 347     switch (obtained.format)
 348     {
 349     case AUDIO_U8:
 350     case AUDIO_S8:
 351         pcm_channel_bytes = 1;
 352         break;
 353     case AUDIO_U16LSB:
 354     case AUDIO_S16LSB:
 355     case AUDIO_U16MSB:
 356     case AUDIO_S16MSB:
 357         pcm_channel_bytes = 2;
 358         break;
 359     default:
 360         DEBUGF("Unknown sample format obtained: %u\n",
 361                 (unsigned)obtained.format);
 362         return;
 363     }
 364
 365     pcm_sample_bytes = obtained.channels * pcm_channel_bytes;
 366
 367     pcm_dma_apply_settings_nolock();
 368 }
 369
 370 void pcm_postinit(void)
 371 {
 372 }
 373
 374 void pcm_set_mixer_volume(int volume)
 375 {
 376     sim_volume = volume;
 377 }
 378
 379 #endif /* CONFIG_CODEC == SWCODEC */