text: /*
    Simple DirectMedia Layer
    Copyright (C) 1997-2022 Sam Lantinga <slouken@libsdl.org>
  
    This software is provided 'as-is', without any express or implied
    warranty.  In no event will the authors be held liable for any damages
    arising from the use of this software.
  
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
  
    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software. If you use this software
       in a product, an acknowledgment in the product documentation would be
       appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
  */
  #include "../../SDL_internal.h"
  
  #if SDL_AUDIO_DRIVER_HAIKU
  
  /* Allow access to the audio stream on Haiku */
  
  #include <SoundPlayer.h>
  #include <signal.h>
  
  #include "../../main/haiku/SDL_BeApp.h"
  
  extern "C"
  {
  
  #include "SDL_audio.h"
  #include "../SDL_audio_c.h"
  #include "../SDL_sysaudio.h"
  #include "SDL_haikuaudio.h"
  
  }
  
  
  /* !!! FIXME: have the callback call the higher level to avoid code dupe. */
  /* The Haiku callback for handling the audio buffer */
  static void
  FillSound(void *device, void *stream, size_t len,
            const media_raw_audio_format & format)
  {
      SDL_AudioDevice *audio = (SDL_AudioDevice *) device;
      SDL_AudioCallback callback = audio->callbackspec.callback;
  
      /* Only do something if audio is enabled */
      if (!SDL_AtomicGet(&audio->enabled) || SDL_AtomicGet(&audio->paused)) {
          if (audio->stream) {
              SDL_AudioStreamClear(audio->stream);
          }
          SDL_memset(stream, audio->spec.silence, len);
          return;
      }
  
      SDL_assert(audio->spec.size == len);
  
      if (audio->stream == NULL) {  /* no conversion necessary. */
          SDL_LockMutex(audio->mixer_lock);
          callback(audio->callbackspec.userdata, (Uint8 *) stream, len);
          SDL_UnlockMutex(audio->mixer_lock);
      } else {  /* streaming/converting */
          const int stream_len = audio->callbackspec.size;
          const int ilen = (int) len;
          while (SDL_AudioStreamAvailable(audio->stream) < ilen) {
              callback(audio->callbackspec.userdata, audio->work_buffer, stream_len);
              if (SDL_AudioStreamPut(audio->stream, audio->work_buffer, stream_len) == -1) {
                  SDL_AudioStreamClear(audio->stream);
                  SDL_AtomicSet(&audio->enabled, 0);
                  break;
              }
          }
  
          const int got = SDL_AudioStreamGet(audio->stream, stream, ilen);
          SDL_assert((got < 0) || (got == ilen));
          if (got != ilen) {
              SDL_memset(stream, audio->spec.silence, len);
          }
      }
  }
  
  static void
  HAIKUAUDIO_CloseDevice(_THIS)
  {
      if (_this->hidden->audio_obj) {
          _this->hidden->audio_obj->Stop();
          delete _this->hidden->audio_obj;
      }
      delete _this->hidden;
  }
  
  
  static const int sig_list[] = {
      SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGALRM, SIGTERM, SIGWINCH, 0
  };
  
  static inline void
  MaskSignals(sigset_t * omask)
  {
      sigset_t mask;
      int i;
  
      sigemptyset(&mask);
      for (i = 0; sig_list[i]; ++i) {
          sigaddset(&mask, sig_list[i]);
      }
      sigprocmask(SIG_BLOCK, &mask, omask);
  }
  
  static inline void
  UnmaskSignals(sigset_t * omask)
  {
      sigprocmask(SIG_SETMASK, omask, NULL);
  }
  
  
  static int
  HAIKUAUDIO_OpenDevice(_THIS, void *handle, const char *devname, int iscapture)
  {
      int valid_datatype = 0;
      media_raw_audio_format format;
      SDL_AudioFormat test_format = SDL_FirstAudioFormat(_this->spec.format);
  
      /* Initialize all variables that we clean on shutdown */
      _this->hidden = new SDL_PrivateAudioData;
      if (_this->hidden == NULL) {
          return SDL_OutOfMemory();
      }
      SDL_zerop(_this->hidden);
  
      /* Parse the audio format and fill the Be raw audio format */
      SDL_zero(format);
      format.byte_order = B_MEDIA_LITTLE_ENDIAN;
      format.frame_rate = (float) _this->spec.freq;
      format.channel_count = _this->spec.channels;        /* !!! FIXME: support > 2? */
      while ((!valid_datatype) && (test_format)) {
          valid_datatype = 1;
          _this->spec.format = test_format;
          switch (test_format) {
          case AUDIO_S8:
              format.format = media_raw_audio_format::B_AUDIO_CHAR;
              break;
  
          case AUDIO_U8:
              format.format = media_raw_audio_format::B_AUDIO_UCHAR;
              break;
  
          case AUDIO_S16LSB:
              format.format = media_raw_audio_format::B_AUDIO_SHORT;
              break;
  
          case AUDIO_S16MSB:
              format.format = media_raw_audio_format::B_AUDIO_SHORT;
              format.byte_order = B_MEDIA_BIG_ENDIAN;
              break;
  
          case AUDIO_S32LSB:
              format.format = media_raw_audio_format::B_AUDIO_INT;
              break;
  
          case AUDIO_S32MSB:
              format.format = media_raw_audio_format::B_AUDIO_INT;
              format.byte_order = B_MEDIA_BIG_ENDIAN;
              break;
  
          case AUDIO_F32LSB:
              format.format = media_raw_audio_format::B_AUDIO_FLOAT;
              break;
  
          case AUDIO_F32MSB:
              format.format = media_raw_audio_format::B_AUDIO_FLOAT;
              format.byte_order = B_MEDIA_BIG_ENDIAN;
              break;
  
          default:
              valid_datatype = 0;
              test_format = SDL_NextAudioFormat();
              break;
          }
      }
  
      if (!valid_datatype) {      /* shouldn't happen, but just in case... */
          return SDL_SetError("Unsupported audio format");
      }
  
      /* Calculate the final parameters for this audio specification */
      SDL_CalculateAudioSpec(&_this->spec);
  
      format.buffer_size = _this->spec.size;
  
      /* Subscribe to the audio stream (creates a new thread) */
      sigset_t omask;
      MaskSignals(&omask);
      _this->hidden->audio_obj = new BSoundPlayer(&format, "SDL Audio",
                                                  FillSound, NULL, _this);
      UnmaskSignals(&omask);
  
      if (_this->hidden->audio_obj->Start() == B_NO_ERROR) {
          _this->hidden->audio_obj->SetHasData(true);
      } else {
          return SDL_SetError("Unable to start Be audio");
      }
  
      /* We're running! */
      return 0;
  }
  
  static void
  HAIKUAUDIO_Deinitialize(void)
  {
      SDL_QuitBeApp();
  }
  
  static int
  HAIKUAUDIO_Init(SDL_AudioDriverImpl * impl)
  {
      /* Initialize the Be Application, if it's not already started */
      if (SDL_InitBeApp() < 0) {
          return 0;
      }
  
      /* Set the function pointers */
      impl->OpenDevice = HAIKUAUDIO_OpenDevice;
      impl->CloseDevice = HAIKUAUDIO_CloseDevice;
      impl->Deinitialize = HAIKUAUDIO_Deinitialize;
      impl->ProvidesOwnCallbackThread = 1;
      impl->OnlyHasDefaultOutputDevice = 1;
  
      return 1;   /* this audio target is available. */
  }
  
  extern "C"
  {
      extern AudioBootStrap HAIKUAUDIO_bootstrap;
  }
  AudioBootStrap HAIKUAUDIO_bootstrap = {
      "haiku", "Haiku BSoundPlayer", HAIKUAUDIO_Init, 0
  };
  
  #endif /* SDL_AUDIO_DRIVER_HAIKU */
  
  /* vi: set ts=4 sw=4 expandtab: */
  