libao2/ao_sdl.c

   1 /*
   2  * ao_sdl.c - libao2 SDLlib Audio Output Driver for MPlayer
   3  *
   4  * This driver is under the same license as MPlayer.
   5  * (http://www.mplayerhq.hu)
   6  *
   7  * Copyleft 2001 by Felix Bünemann (atmosfear@users.sf.net)
   8  *
   9  * Thanks to Arpi for nice ringbuffer-code!
  10  *
  11  */
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16
  17 #include "config.h"
  18 #include "mp_msg.h"
  19 #include "help_mp.h"
  20
  21 #include "audio_out.h"
  22 #include "audio_out_internal.h"
  23 #include "libaf/af_format.h"
  24 #include <SDL.h>
  25 #include "osdep/timer.h"
  26
  27 #include "libvo/fastmemcpy.h"
  28
  29 static ao_info_t info =
  30 {
  31         "SDLlib audio output",
  32         "sdl",
  33         "Felix Buenemann <atmosfear@users.sourceforge.net>",
  34         ""
  35 };
  36
  37 LIBAO_EXTERN(sdl)
  38
  39 // turn this on if you want to use the slower SDL_MixAudio
  40 #undef USE_SDL_INTERNAL_MIXER
  41
  42 // Samplesize used by the SDLlib AudioSpec struct
  43 #if defined(WIN32) || defined(__AMIGAOS4__)
  44 #define SAMPLESIZE 2048
  45 #else
  46 #define SAMPLESIZE 1024
  47 #endif
  48
  49 #define CHUNK_SIZE 4096
  50 #define NUM_CHUNKS 8
  51 // This type of ring buffer may never fill up completely, at least
  52 // one byte must always be unused.
  53 // For performance reasons (alignment etc.) one whole chunk always stays
  54 // empty, not only one byte.
  55 #define BUFFSIZE ((NUM_CHUNKS + 1) * CHUNK_SIZE)
  56
  57 static unsigned char *buffer;
  58
  59 // may only be modified by SDL's playback thread or while it is stopped
  60 static volatile int read_pos;
  61 // may only be modified by mplayer's thread
  62 static volatile int write_pos;
  63 #ifdef USE_SDL_INTERNAL_MIXER
  64 static unsigned char volume=SDL_MIX_MAXVOLUME;
  65 #endif
  66
  67 // may only be called by mplayer's thread
  68 // return value may change between immediately following two calls,
  69 // and the real number of free bytes might be larger!
  70 static int buf_free(void) {
  71   int free = read_pos - write_pos - CHUNK_SIZE;
  72   if (free < 0) free += BUFFSIZE;
  73   return free;
  74 }
  75
  76 // may only be called by SDL's playback thread
  77 // return value may change between immediately following two calls,
  78 // and the real number of buffered bytes might be larger!
  79 static int buf_used(void) {
  80   int used = write_pos - read_pos;
  81   if (used < 0) used += BUFFSIZE;
  82   return used;
  83 }
  84
  85 static int write_buffer(unsigned char* data,int len){
  86   int first_len = BUFFSIZE - write_pos;
  87   int free = buf_free();
  88   if (len > free) len = free;
  89   if (first_len > len) first_len = len;
  90   // till end of buffer
  91   fast_memcpy (&buffer[write_pos], data, first_len);
  92   if (len > first_len) { // we have to wrap around
  93     // remaining part from beginning of buffer
  94     fast_memcpy (buffer, &data[first_len], len - first_len);
  95   }
  96   write_pos = (write_pos + len) % BUFFSIZE;
  97   return len;
  98 }
  99
 100 static int read_buffer(unsigned char* data,int len){
 101   int first_len = BUFFSIZE - read_pos;
 102   int buffered = buf_used();
 103   if (len > buffered) len = buffered;
 104   if (first_len > len) first_len = len;
 105   // till end of buffer
 106 #ifdef USE_SDL_INTERNAL_MIXER
 107   SDL_MixAudio (data, &buffer[read_pos], first_len, volume);
 108 #else
 109   fast_memcpy (data, &buffer[read_pos], first_len);
 110 #endif
 111   if (len > first_len) { // we have to wrap around
 112     // remaining part from beginning of buffer
 113 #ifdef USE_SDL_INTERNAL_MIXER
 114     SDL_MixAudio (&data[first_len], buffer, len - first_len, volume);
 115 #else
 116     fast_memcpy (&data[first_len], buffer, len - first_len);
 117 #endif
 118   }
 119   read_pos = (read_pos + len) % BUFFSIZE;
 120   return len;
 121 }
 122
 123 // end ring buffer stuff
 124
 125
 126 // to set/get/query special features/parameters
 127 static int control(int cmd,void *arg){
 128 #ifdef USE_SDL_INTERNAL_MIXER
 129         switch (cmd) {
 130                 case AOCONTROL_GET_VOLUME:
 131                 {
 132                         ao_control_vol_t* vol = (ao_control_vol_t*)arg;
 133                         vol->left = vol->right = volume * 100 / SDL_MIX_MAXVOLUME;
 134                         return CONTROL_OK;
 135                 }
 136                 case AOCONTROL_SET_VOLUME:
 137                 {
 138                         int diff;
 139                         ao_control_vol_t* vol = (ao_control_vol_t*)arg;
 140                         diff = (vol->left+vol->right) / 2;
 141                         volume = diff * SDL_MIX_MAXVOLUME / 100;
 142                         return CONTROL_OK;
 143                 }
 144         }
 145 #endif
 146         return CONTROL_UNKNOWN;
 147 }
 148
 149 // SDL Callback function
 150 void outputaudio(void *unused, Uint8 *stream, int len) {
 151         //SDL_MixAudio(stream, read_buffer(buffers, len), len, SDL_MIX_MAXVOLUME);
 152         //if(!full_buffers) printf("SDL: Buffer underrun!\n");
 153
 154         read_buffer(stream, len);
 155         //printf("SDL: Full Buffers: %i\n", full_buffers);
 156 }
 157
 158 // open & setup audio device
 159 // return: 1=success 0=fail
 160 static int init(int rate,int channels,int format,int flags){
 161
 162         /* SDL Audio Specifications */
 163         SDL_AudioSpec aspec, obtained;
 164
 165         /* Allocate ring-buffer memory */
 166         buffer = (unsigned char *) malloc(BUFFSIZE);
 167
 168         mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_SDL_INFO, rate, (channels > 1) ? "Stereo" : "Mono", af_fmt2str_short(format));
 169
 170         if(ao_subdevice) {
 171                 setenv("SDL_AUDIODRIVER", ao_subdevice, 1);
 172                 mp_msg(MSGT_AO,MSGL_INFO,MSGTR_AO_SDL_DriverInfo, ao_subdevice);
 173         }
 174
 175         ao_data.channels=channels;
 176         ao_data.samplerate=rate;
 177         ao_data.format=format;
 178
 179         ao_data.bps=channels*rate;
 180         if(format != AF_FORMAT_U8 && format != AF_FORMAT_S8)
 181           ao_data.bps*=2;
 182
 183         /* The desired audio format (see SDL_AudioSpec) */
 184         switch(format) {
 185             case AF_FORMAT_U8:
 186                 aspec.format = AUDIO_U8;
 187             break;
 188             case AF_FORMAT_S16_LE:
 189                 aspec.format = AUDIO_S16LSB;
 190             break;
 191             case AF_FORMAT_S16_BE:
 192                 aspec.format = AUDIO_S16MSB;
 193             break;
 194             case AF_FORMAT_S8:
 195                 aspec.format = AUDIO_S8;
 196             break;
 197             case AF_FORMAT_U16_LE:
 198                 aspec.format = AUDIO_U16LSB;
 199             break;
 200             case AF_FORMAT_U16_BE:
 201                 aspec.format = AUDIO_U16MSB;
 202             break;
 203             default:
 204                 aspec.format = AUDIO_S16LSB;
 205                 ao_data.format = AF_FORMAT_S16_LE;
 206                 mp_msg(MSGT_AO,MSGL_WARN,MSGTR_AO_SDL_UnsupportedAudioFmt, format);
 207         }
 208
 209         /* The desired audio frequency in samples-per-second. */
 210         aspec.freq     = rate;
 211
 212         /* Number of channels (mono/stereo) */
 213         aspec.channels = channels;
 214
 215         /* The desired size of the audio buffer in samples. This number should be a power of two, and may be adjusted by the audio driver to a value more suitable for the hardware. Good values seem to range between 512 and 8192 inclusive, depending on the application and CPU speed. Smaller values yield faster response time, but can lead to underflow if the application is doing heavy processing and cannot fill the audio buffer in time. A stereo sample consists of both right and left channels in LR ordering. Note that the number of samples is directly related to time by the following formula: ms = (samples*1000)/freq */
 216         aspec.samples  = SAMPLESIZE;
 217
 218         /* This should be set to a function that will be called when the audio device is ready for more data. It is passed a pointer to the audio buffer, and the length in bytes of the audio buffer. This function usually runs in a separate thread, and so you should protect data structures that it accesses by calling SDL_LockAudio and SDL_UnlockAudio in your code. The callback prototype is:
 219 void callback(void *userdata, Uint8 *stream, int len); userdata is the pointer stored in userdata field of the SDL_AudioSpec. stream is a pointer to the audio buffer you want to fill with information and len is the length of the audio buffer in bytes. */
 220         aspec.callback = outputaudio;
 221
 222         /* This pointer is passed as the first parameter to the callback function. */
 223         aspec.userdata = NULL;
 224
 225         /* initialize the SDL Audio system */
 226         if (SDL_Init (SDL_INIT_AUDIO/*|SDL_INIT_NOPARACHUTE*/)) {
 227                 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_SDL_CantInit, SDL_GetError());
 228                 return 0;
 229         }
 230
 231         /* Open the audio device and start playing sound! */
 232         if(SDL_OpenAudio(&aspec, &obtained) < 0) {
 233                 mp_msg(MSGT_AO,MSGL_ERR,MSGTR_AO_SDL_CantOpenAudio, SDL_GetError());
 234                 return(0);
 235         }
 236
 237         /* did we got what we wanted ? */
 238         ao_data.channels=obtained.channels;
 239         ao_data.samplerate=obtained.freq;
 240
 241         switch(obtained.format) {
 242             case AUDIO_U8 :
 243                 ao_data.format = AF_FORMAT_U8;
 244             break;
 245             case AUDIO_S16LSB :
 246                 ao_data.format = AF_FORMAT_S16_LE;
 247             break;
 248             case AUDIO_S16MSB :
 249                 ao_data.format = AF_FORMAT_S16_BE;
 250             break;
 251             case AUDIO_S8 :
 252                 ao_data.format = AF_FORMAT_S8;
 253             break;
 254             case AUDIO_U16LSB :
 255                 ao_data.format = AF_FORMAT_U16_LE;
 256             break;
 257             case AUDIO_U16MSB :
 258                 ao_data.format = AF_FORMAT_U16_BE;
 259             break;
 260             default:
 261                 mp_msg(MSGT_AO,MSGL_WARN,MSGTR_AO_SDL_UnsupportedAudioFmt, obtained.format);
 262                 return 0;
 263         }
 264
 265         mp_msg(MSGT_AO,MSGL_V,"SDL: buf size = %d\n",obtained.size);
 266         ao_data.buffersize=obtained.size;
 267         ao_data.outburst = CHUNK_SIZE;
 268
 269         reset();
 270         /* unsilence audio, if callback is ready */
 271         SDL_PauseAudio(0);
 272
 273         return 1;
 274 }
 275
 276 // close audio device
 277 static void uninit(int immed){
 278         mp_msg(MSGT_AO,MSGL_V,"SDL: Audio Subsystem shutting down!\n");
 279         if (!immed)
 280           usec_sleep(get_delay() * 1000 * 1000);
 281         SDL_CloseAudio();
 282         SDL_QuitSubSystem(SDL_INIT_AUDIO);
 283 }
 284
 285 // stop playing and empty buffers (for seeking/pause)
 286 static void reset(void){
 287
 288         //printf("SDL: reset called!\n");
 289
 290         SDL_PauseAudio(1);
 291         /* Reset ring-buffer state */
 292         read_pos = 0;
 293         write_pos = 0;
 294         SDL_PauseAudio(0);
 295 }
 296
 297 // stop playing, keep buffers (for pause)
 298 static void audio_pause(void)
 299 {
 300
 301         //printf("SDL: audio_pause called!\n");
 302         SDL_PauseAudio(1);
 303
 304 }
 305
 306 // resume playing, after audio_pause()
 307 static void audio_resume(void)
 308 {
 309         //printf("SDL: audio_resume called!\n");
 310         SDL_PauseAudio(0);
 311 }
 312
 313
 314 // return: how many bytes can be played without blocking
 315 static int get_space(void){
 316     return buf_free();
 317 }
 318
 319 // plays 'len' bytes of 'data'
 320 // it should round it down to outburst*n
 321 // return: number of bytes played
 322 static int play(void* data,int len,int flags){
 323
 324         if (!(flags & AOPLAY_FINAL_CHUNK))
 325         len = (len/ao_data.outburst)*ao_data.outburst;
 326 #if 0
 327         int ret;
 328
 329         /* Audio locking prohibits call of outputaudio */
 330         SDL_LockAudio();
 331         // copy audio stream into ring-buffer
 332         ret = write_buffer(data, len);
 333         SDL_UnlockAudio();
 334
 335         return ret;
 336 #else
 337         return write_buffer(data, len);
 338 #endif
 339 }
 340
 341 // return: delay in seconds between first and last sample in buffer
 342 static float get_delay(void){
 343     int buffered = BUFFSIZE - CHUNK_SIZE - buf_free(); // could be less
 344     return (float)(buffered + ao_data.buffersize)/(float)ao_data.bps;
 345 }
 346
 347
 348
 349
 350
 351