uisimulator/sdl/sound.c

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