src/audio/baudio/SDL_beaudio.cc
author Sam Lantinga <slouken@libsdl.org>
Mon, 08 Dec 2008 00:25:42 +0000
branchSDL-1.2
changeset 4159 a1b03ba2fcd0
parent 3852 5b5e549382b3
child 6137 4720145f848b
permissions -rw-r--r--
Updated copyright date
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997-2009 Sam Lantinga
     4 
     5     This library is free software; you can redistribute it and/or
     6     modify it under the terms of the GNU Lesser General Public
     7     License as published by the Free Software Foundation; either
     8     version 2.1 of the License, or (at your option) any later version.
     9 
    10     This library is distributed in the hope that it will be useful,
    11     but WITHOUT ANY WARRANTY; without even the implied warranty of
    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13     Lesser General Public License for more details.
    14 
    15     You should have received a copy of the GNU Lesser General Public
    16     License along with this library; if not, write to the Free Software
    17     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 */
    22 #include "SDL_config.h"
    23 
    24 /* Allow access to the audio stream on BeOS */
    25 
    26 #include <SoundPlayer.h>
    27 
    28 #include "../../main/beos/SDL_BeApp.h"
    29 
    30 extern "C" {
    31 
    32 #include "SDL_audio.h"
    33 #include "../SDL_audio_c.h"
    34 #include "../SDL_sysaudio.h"
    35 #include "../../thread/beos/SDL_systhread_c.h"
    36 #include "SDL_beaudio.h"
    37 
    38 
    39 /* Audio driver functions */
    40 static int BE_OpenAudio(_THIS, SDL_AudioSpec *spec);
    41 static void BE_WaitAudio(_THIS);
    42 static void BE_PlayAudio(_THIS);
    43 static Uint8 *BE_GetAudioBuf(_THIS);
    44 static void BE_CloseAudio(_THIS);
    45 
    46 /* Audio driver bootstrap functions */
    47 
    48 static int Audio_Available(void)
    49 {
    50 	return(1);
    51 }
    52 
    53 static void Audio_DeleteDevice(SDL_AudioDevice *device)
    54 {
    55 	SDL_free(device->hidden);
    56 	SDL_free(device);
    57 }
    58 
    59 static SDL_AudioDevice *Audio_CreateDevice(int devindex)
    60 {
    61 	SDL_AudioDevice *device;
    62 
    63 	/* Initialize all variables that we clean on shutdown */
    64 	device = (SDL_AudioDevice *)SDL_malloc(sizeof(SDL_AudioDevice));
    65 	if ( device ) {
    66 		SDL_memset(device, 0, (sizeof *device));
    67 		device->hidden = (struct SDL_PrivateAudioData *)
    68 				SDL_malloc((sizeof *device->hidden));
    69 	}
    70 	if ( (device == NULL) || (device->hidden == NULL) ) {
    71 		SDL_OutOfMemory();
    72 		if ( device ) {
    73 			SDL_free(device);
    74 		}
    75 		return(0);
    76 	}
    77 	SDL_memset(device->hidden, 0, (sizeof *device->hidden));
    78 
    79 	/* Set the function pointers */
    80 	device->OpenAudio = BE_OpenAudio;
    81 	device->WaitAudio = BE_WaitAudio;
    82 	device->PlayAudio = BE_PlayAudio;
    83 	device->GetAudioBuf = BE_GetAudioBuf;
    84 	device->CloseAudio = BE_CloseAudio;
    85 
    86 	device->free = Audio_DeleteDevice;
    87 
    88 	return device;
    89 }
    90 
    91 AudioBootStrap BAUDIO_bootstrap = {
    92 	"baudio", "BeOS BSoundPlayer",
    93 	Audio_Available, Audio_CreateDevice
    94 };
    95 
    96 /* The BeOS callback for handling the audio buffer */
    97 static void FillSound(void *device, void *stream, size_t len, 
    98 					const media_raw_audio_format &format)
    99 {
   100 	SDL_AudioDevice *audio = (SDL_AudioDevice *)device;
   101 
   102 	/* Silence the buffer, since it's ours */
   103 	SDL_memset(stream, audio->spec.silence, len);
   104 
   105 	/* Only do soemthing if audio is enabled */
   106 	if ( ! audio->enabled )
   107 		return;
   108 
   109 	if ( ! audio->paused ) {
   110 		if ( audio->convert.needed ) {
   111 			SDL_mutexP(audio->mixer_lock);
   112 			(*audio->spec.callback)(audio->spec.userdata,
   113 				(Uint8 *)audio->convert.buf,audio->convert.len);
   114 			SDL_mutexV(audio->mixer_lock);
   115 			SDL_ConvertAudio(&audio->convert);
   116 			SDL_memcpy(stream,audio->convert.buf,audio->convert.len_cvt);
   117 		} else {
   118 			SDL_mutexP(audio->mixer_lock);
   119 			(*audio->spec.callback)(audio->spec.userdata,
   120 						(Uint8 *)stream, len);
   121 			SDL_mutexV(audio->mixer_lock);
   122 		}
   123 	}
   124 	return;
   125 }
   126 
   127 /* Dummy functions -- we don't use thread-based audio */
   128 void BE_WaitAudio(_THIS)
   129 {
   130 	return;
   131 }
   132 void BE_PlayAudio(_THIS)
   133 {
   134 	return;
   135 }
   136 Uint8 *BE_GetAudioBuf(_THIS)
   137 {
   138 	return(NULL);
   139 }
   140 
   141 void BE_CloseAudio(_THIS)
   142 {
   143 	if ( audio_obj ) {
   144 		audio_obj->Stop();
   145 		delete audio_obj;
   146 		audio_obj = NULL;
   147 	}
   148 
   149 	/* Quit the Be Application, if there's nothing left to do */
   150 	SDL_QuitBeApp();
   151 }
   152 
   153 int BE_OpenAudio(_THIS, SDL_AudioSpec *spec)
   154 {
   155     int valid_datatype = 0;
   156     media_raw_audio_format format;
   157     Uint16 test_format = SDL_FirstAudioFormat(spec->format);
   158 
   159     /* Parse the audio format and fill the Be raw audio format */
   160     memset(&format, '\0', sizeof (media_raw_audio_format));
   161     format.byte_order = B_MEDIA_LITTLE_ENDIAN;
   162     format.frame_rate = (float) spec->freq;
   163     format.channel_count = spec->channels;  /* !!! FIXME: support > 2? */
   164     while ((!valid_datatype) && (test_format)) {
   165         valid_datatype = 1;
   166         spec->format = test_format;
   167         switch (test_format) {
   168             case AUDIO_S8:
   169                 format.format = media_raw_audio_format::B_AUDIO_CHAR;
   170                 break;
   171 
   172             case AUDIO_U8:
   173                 format.format = media_raw_audio_format::B_AUDIO_UCHAR;
   174                 break;
   175 
   176             case AUDIO_S16LSB:
   177                 format.format = media_raw_audio_format::B_AUDIO_SHORT;
   178                 break;
   179 
   180             case AUDIO_S16MSB:
   181                 format.format = media_raw_audio_format::B_AUDIO_SHORT;
   182                 format.byte_order = B_MEDIA_BIG_ENDIAN;
   183                 break;
   184 
   185             default:
   186                 valid_datatype = 0;
   187                 test_format = SDL_NextAudioFormat();
   188                 break;
   189         }
   190     }
   191 
   192     if (!valid_datatype) { /* shouldn't happen, but just in case... */
   193         SDL_SetError("Unsupported audio format");
   194         return (-1);
   195     }
   196 
   197     /* Initialize the Be Application, if it's not already started */
   198     if (SDL_InitBeApp() < 0) {
   199         return (-1);
   200     }
   201 
   202     format.buffer_size = spec->samples;
   203 
   204 	/* Calculate the final parameters for this audio specification */
   205 	SDL_CalculateAudioSpec(spec);
   206 
   207 	/* Subscribe to the audio stream (creates a new thread) */
   208 	{ sigset_t omask;
   209 		SDL_MaskSignals(&omask);
   210 		audio_obj = new BSoundPlayer(&format, "SDL Audio", FillSound,
   211 		                                                 NULL, _this);
   212 		SDL_UnmaskSignals(&omask);
   213 	}
   214 	if ( audio_obj->Start() == B_NO_ERROR ) {
   215 		audio_obj->SetHasData(true);
   216 	} else {
   217 		SDL_SetError("Unable to start Be audio");
   218 		return(-1);
   219 	}
   220 
   221 	/* We're running! */
   222 	return(1);
   223 }
   224 
   225 };	/* Extern C */