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 static unsigned long pcm_frequency = SAMPR_44;
  37
  38 static Uint8* pcm_data;
  39 static size_t pcm_data_size;
  40 static size_t pcm_sample_bytes;
  41 static size_t pcm_channel_bytes;
  42
  43 struct pcm_udata
  44 {
  45     Uint8 *stream;
  46     Uint32 num_in;
  47     Uint32 num_out;
  48     FILE  *debug;
  49 } udata;
  50
  51 static SDL_AudioSpec obtained;
  52 static SDL_AudioCVT cvt;
  53
  54 extern bool debug_audio;
  55
  56 #ifndef MIN
  57 #define MIN(a, b) (((a) < (b)) ? (a) : (b))
  58 #endif
  59
  60 void pcm_play_lock(void)
  61 {
  62     SDL_LockAudio();
  63 }
  64
  65 void pcm_play_unlock(void)
  66 {
  67     SDL_UnlockAudio();
  68 }
  69
  70 static void pcm_apply_settings_nolock(void)
  71 {
  72     cvt_status = SDL_BuildAudioCVT(&cvt, AUDIO_S16SYS, 2, pcm_frequency,
  73                     obtained.format, obtained.channels, obtained.freq);
  74
  75     pcm_curr_sampr = pcm_frequency;
  76
  77     if (cvt_status < 0) {
  78         cvt.len_ratio = (double)obtained.freq / (double)pcm_curr_sampr;
  79     }
  80 }
  81
  82 void pcm_apply_settings(void)
  83 {
  84     pcm_play_lock();
  85     pcm_apply_settings_nolock();
  86     pcm_play_unlock();
  87 }
  88
  89 void pcm_play_dma_start(const void *addr, size_t size)
  90 {
  91     pcm_apply_settings_nolock();
  92
  93     pcm_data = (Uint8 *) addr;
  94     pcm_data_size = size;
  95
  96     SDL_PauseAudio(0);
  97 }
  98
  99 void pcm_play_dma_stop(void)
 100 {
 101     SDL_PauseAudio(1);
 102 }
 103
 104 void pcm_play_dma_pause(bool pause)
 105 {
 106     if (pause)
 107         SDL_PauseAudio(1);
 108     else
 109         SDL_PauseAudio(0);
 110 }
 111
 112 size_t pcm_get_bytes_waiting(void)
 113 {
 114     return pcm_data_size;
 115 }
 116
 117 void pcm_set_frequency(unsigned int frequency)
 118 {
 119     switch (frequency)
 120     {
 121     HW_HAVE_8_( case SAMPR_8:)
 122     HW_HAVE_11_(case SAMPR_11:)
 123     HW_HAVE_12_(case SAMPR_12:)
 124     HW_HAVE_16_(case SAMPR_16:)
 125     HW_HAVE_22_(case SAMPR_22:)
 126     HW_HAVE_24_(case SAMPR_24:)
 127     HW_HAVE_32_(case SAMPR_32:)
 128     HW_HAVE_44_(case SAMPR_44:)
 129     HW_HAVE_48_(case SAMPR_48:)
 130     HW_HAVE_64_(case SAMPR_64:)
 131     HW_HAVE_88_(case SAMPR_88:)
 132     HW_HAVE_96_(case SAMPR_96:)
 133         break;
 134     default:
 135         frequency = SAMPR_44;
 136     }
 137
 138     pcm_frequency = frequency;
 139 }
 140
 141 extern int sim_volume; /* in firmware/sound.c */
 142 void write_to_soundcard(struct pcm_udata *udata) {
 143     if (cvt.needed) {
 144         Uint32 rd = udata->num_in;
 145         Uint32 wr = (double)rd * cvt.len_ratio;
 146
 147         if (wr > udata->num_out) {
 148             wr = udata->num_out;
 149             rd = (double)wr / cvt.len_ratio;
 150
 151             if (rd > udata->num_in)
 152             {
 153                 rd = udata->num_in;
 154                 wr = (double)rd * cvt.len_ratio;
 155             }
 156         }
 157
 158         if (wr == 0 || rd == 0)
 159         {
 160             udata->num_out = udata->num_in = 0;
 161             return;
 162         }
 163
 164         if (cvt_status > 0) {
 165             cvt.len = rd * pcm_sample_bytes;
 166             cvt.buf = (Uint8 *) malloc(cvt.len * cvt.len_mult);
 167
 168             memcpy(cvt.buf, pcm_data, cvt.len);
 169
 170             SDL_ConvertAudio(&cvt);
 171             SDL_MixAudio(udata->stream, cvt.buf, cvt.len_cvt, sim_volume);
 172
 173             udata->num_in = cvt.len / pcm_sample_bytes;
 174             udata->num_out = cvt.len_cvt / pcm_sample_bytes;
 175
 176             if (udata->debug != NULL) {
 177                fwrite(cvt.buf, sizeof(Uint8), cvt.len_cvt, udata->debug);
 178             }
 179
 180             free(cvt.buf);
 181         }
 182         else {
 183             /* Convert is bad, so do silence */
 184             Uint32 num = wr*obtained.channels;
 185             udata->num_in = rd;
 186             udata->num_out = wr;
 187
 188             switch (pcm_channel_bytes)
 189             {
 190             case 1:
 191             {
 192                 Uint8 *stream = udata->stream;
 193                 while (num-- > 0)
 194                     *stream++ = obtained.silence;
 195                 break;
 196                 }
 197             case 2:
 198             {
 199                 Uint16 *stream = (Uint16 *)udata->stream;
 200                 while (num-- > 0)
 201                     *stream++ = obtained.silence;
 202                 break;
 203                 }
 204             }
 205
 206             if (udata->debug != NULL) {
 207                fwrite(udata->stream, sizeof(Uint8), wr, udata->debug);
 208             }
 209         }
 210     } else {
 211         udata->num_in = udata->num_out = MIN(udata->num_in, udata->num_out);
 212         SDL_MixAudio(udata->stream, pcm_data,
 213                      udata->num_out * pcm_sample_bytes, sim_volume);
 214
 215         if (udata->debug != NULL) {
 216            fwrite(pcm_data, sizeof(Uint8), udata->num_out * pcm_sample_bytes,
 217                   udata->debug);
 218         }
 219     }
 220 }
 221
 222 void sdl_audio_callback(struct pcm_udata *udata, Uint8 *stream, int len)
 223 {
 224     udata->stream = stream;
 225
 226     /* Write what we have in the PCM buffer */
 227     if (pcm_data_size > 0)
 228         goto start;
 229
 230     /* Audio card wants more? Get some more then. */
 231     while (len > 0) {
 232         if ((ssize_t)pcm_data_size <= 0) {
 233             pcm_data_size = 0;
 234
 235             if (pcm_callback_for_more)
 236                 pcm_callback_for_more(&pcm_data, &pcm_data_size);
 237         }
 238
 239         if (pcm_data_size > 0) {
 240     start:
 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             pcm_play_dma_stop();
 256             pcm_play_dma_stopped_callback();
 257             break;
 258         }
 259     }
 260 }
 261
 262 const void * pcm_play_dma_get_peak_buffer(int *count)
 263 {
 264     uintptr_t addr = (uintptr_t)pcm_data;
 265     *count = pcm_data_size / 4;
 266     return (void *)((addr + 2) & ~3);
 267 }
 268
 269 #ifdef HAVE_RECORDING
 270 void pcm_rec_lock(void)
 271 {
 272 }
 273
 274 void pcm_rec_unlock(void)
 275 {
 276 }
 277
 278 void pcm_rec_dma_init(void)
 279 {
 280 }
 281
 282 void pcm_rec_dma_close(void)
 283 {
 284 }
 285
 286 void pcm_rec_dma_start(void *start, size_t size)
 287 {
 288     (void)start;
 289     (void)size;
 290 }
 291
 292 void pcm_rec_dma_stop(void)
 293 {
 294 }
 295
 296 void pcm_record_more(void *start, size_t size)
 297 {
 298     (void)start;
 299     (void)size;
 300 }
 301
 302 unsigned long pcm_rec_status(void)
 303 {
 304     return 0;
 305 }
 306
 307 const void * pcm_rec_dma_get_peak_buffer(int *count)
 308 {
 309     *count = 0;
 310     return NULL;
 311 }
 312
 313 #endif /* HAVE_RECORDING */
 314
 315 void pcm_play_dma_init(void)
 316 {
 317     SDL_AudioSpec wanted_spec;
 318     udata.debug = NULL;
 319
 320     if (debug_audio) {
 321         udata.debug = fopen("audiodebug.raw", "wb");
 322     }
 323
 324     /* Set 16-bit stereo audio at 44Khz */
 325     wanted_spec.freq = 44100;
 326     wanted_spec.format = AUDIO_S16SYS;
 327     wanted_spec.channels = 2;
 328     wanted_spec.samples = 2048;
 329     wanted_spec.callback =
 330         (void (SDLCALL *)(void *userdata,
 331             Uint8 *stream, int len))sdl_audio_callback;
 332     wanted_spec.userdata = &udata;
 333
 334     /* Open the audio device and start playing sound! */
 335     if(SDL_OpenAudio(&wanted_spec, &obtained) < 0) {
 336         fprintf(stderr, "Unable to open audio: %s\n", SDL_GetError());
 337         return;
 338     }
 339
 340     switch (obtained.format)
 341     {
 342     case AUDIO_U8:
 343     case AUDIO_S8:
 344         pcm_channel_bytes = 1;
 345         break;
 346     case AUDIO_U16LSB:
 347     case AUDIO_S16LSB:
 348     case AUDIO_U16MSB:
 349     case AUDIO_S16MSB:
 350         pcm_channel_bytes = 2;
 351         break;
 352     default:
 353         fprintf(stderr, "Unknown sample format obtained: %u\n",
 354                 (unsigned)obtained.format);
 355         return;
 356     }
 357
 358     pcm_sample_bytes = obtained.channels * pcm_channel_bytes;
 359
 360     pcm_apply_settings_nolock();
 361 }
 362
 363 void pcm_postinit(void)
 364 {
 365 }