972
|
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://mplayer.sf.net)
|
|
6 *
|
|
7 * Copyleft 2001 by Felix Bünemann (atmosfear@users.sf.net)
|
|
8 *
|
|
9 * Thanks to Arpi for nice ringbuffer-code!
|
|
10 *
|
|
11 */
|
|
12
|
966
|
13 #include <stdio.h>
|
|
14
|
|
15 #include "audio_out.h"
|
|
16 #include "audio_out_internal.h"
|
|
17
|
972
|
18 #include "../libvo/fastmemcpy.h"
|
|
19
|
966
|
20 static ao_info_t info =
|
|
21 {
|
|
22 "SDLlib audio output",
|
|
23 "sdl",
|
|
24 "Felix Buenemann <atmosfear@users.sourceforge.net>",
|
|
25 ""
|
|
26 };
|
|
27
|
|
28 LIBAO_EXTERN(sdl)
|
|
29
|
|
30 // there are some globals:
|
|
31 // ao_samplerate
|
|
32 // ao_channels
|
|
33 // ao_format
|
|
34 // ao_bps
|
|
35 // ao_outburst
|
|
36 // ao_buffersize
|
|
37
|
972
|
38 // Samplesize used by the SDLlib AudioSpec struct
|
|
39 #define SAMPLESIZE 512
|
|
40
|
|
41 // General purpose Ring-buffering routines
|
|
42
|
974
|
43 #define BUFFSIZE 4096
|
|
44 #define NUM_BUFS 16
|
972
|
45
|
|
46 static unsigned char *buffer[NUM_BUFS];
|
|
47
|
|
48 static unsigned int buf_read=0;
|
|
49 static unsigned int buf_write=0;
|
|
50 static unsigned int buf_read_pos=0;
|
|
51 static unsigned int buf_write_pos=0;
|
|
52
|
|
53 static int full_buffers=0;
|
|
54 static int buffered_bytes=0;
|
|
55
|
|
56 static int write_buffer(unsigned char* data,int len){
|
|
57 int len2=0;
|
|
58 int x;
|
|
59 while(len>0){
|
|
60 if(full_buffers==NUM_BUFS) break;
|
|
61 x=BUFFSIZE-buf_write_pos;
|
|
62 if(x>len) x=len;
|
|
63 memcpy(buffer[buf_write]+buf_write_pos,data+len2,x);
|
|
64 len2+=x; len-=x;
|
|
65 buffered_bytes+=x; buf_write_pos+=x;
|
|
66 if(buf_write_pos>=BUFFSIZE){
|
|
67 // block is full, find next!
|
|
68 buf_write=(buf_write+1)%NUM_BUFS;
|
|
69 ++full_buffers;
|
|
70 buf_write_pos=0;
|
|
71 }
|
|
72 }
|
|
73 return len2;
|
|
74 }
|
|
75
|
|
76 static int read_buffer(unsigned char* data,int len){
|
|
77 int len2=0;
|
|
78 int x;
|
|
79 while(len>0){
|
|
80 if(full_buffers==0) break; // no more data buffered!
|
|
81 x=BUFFSIZE-buf_read_pos;
|
|
82 if(x>len) x=len;
|
|
83 memcpy(data+len2,buffer[buf_read]+buf_read_pos,x);
|
|
84 len2+=x; len-=x;
|
|
85 buffered_bytes-=x; buf_read_pos+=x;
|
|
86 if(buf_read_pos>=BUFFSIZE){
|
|
87 // block is empty, find next!
|
|
88 buf_read=(buf_read+1)%NUM_BUFS;
|
|
89 --full_buffers;
|
|
90 buf_read_pos=0;
|
|
91 }
|
|
92 }
|
|
93 return len2;
|
|
94 }
|
|
95
|
|
96 // end ring buffer stuff
|
966
|
97
|
|
98 #ifdef __FreeBSD__
|
|
99 #include <SDL11/SDL.h>
|
|
100 #else
|
|
101 #include <SDL/SDL.h>
|
|
102 #endif
|
|
103
|
|
104 // to set/get/query special features/parameters
|
|
105 static int control(int cmd,int arg){
|
|
106 return -1;
|
|
107 }
|
|
108
|
972
|
109 // SDL Callback function
|
|
110 void outputaudio(void *unused, Uint8 *stream, int len) {
|
|
111 //SDL_MixAudio(stream, read_buffer(buffers, len), len, SDL_MIX_MAXVOLUME);
|
|
112 read_buffer(stream, len);
|
966
|
113 }
|
|
114
|
|
115 // open & setup audio device
|
|
116 // return: 1=success 0=fail
|
|
117 static int init(int rate,int channels,int format,int flags){
|
|
118
|
972
|
119 /* SDL Audio Specifications */
|
|
120 SDL_AudioSpec aspec;
|
|
121
|
|
122 int i;
|
|
123 /* Allocate ring-buffer memory */
|
|
124 for(i=0;i<NUM_BUFS;i++) buffer[i]=malloc(BUFFSIZE);
|
|
125
|
|
126 printf("SDL: Samplerate: %iHz Channels: %s Format %iBit\n", rate, (channels > 1) ? "Stereo" : "Mono", format);
|
966
|
127
|
|
128 /* The desired audio frequency in samples-per-second. */
|
|
129 aspec.freq = rate;
|
|
130
|
|
131 /* The desired audio format (see SDL_AudioSpec) */
|
972
|
132 aspec.format = (format == 16) ? AUDIO_S16 : AUDIO_U8;
|
966
|
133
|
|
134 /* Number of channels (mono/stereo) */
|
|
135 aspec.channels = channels;
|
|
136
|
|
137 /* 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 */
|
972
|
138 aspec.samples = SAMPLESIZE;
|
966
|
139
|
|
140 /* 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:
|
|
141 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. */
|
972
|
142 aspec.callback = outputaudio;
|
966
|
143
|
|
144 /* This pointer is passed as the first parameter to the callback function. */
|
|
145 aspec.userdata = NULL;
|
|
146
|
972
|
147 /* initialize the SDL Audio system */
|
|
148 if (SDL_Init (SDL_INIT_AUDIO/*|SDL_INIT_NOPARACHUTE*/)) {
|
|
149 printf("SDL: Initializing of SDL Audio failed: %s.\n", SDL_GetError());
|
|
150 return 0;
|
|
151 }
|
|
152
|
966
|
153 /* Open the audio device and start playing sound! */
|
|
154 if(SDL_OpenAudio(&aspec, NULL) < 0) {
|
|
155 printf("SDL: Unable to open audio: %s\n", SDL_GetError());
|
|
156 return(0);
|
|
157 }
|
|
158
|
974
|
159 printf("SDL buf size = %d\n",aspec.size);
|
|
160 if(ao_buffersize==-1) ao_buffersize=16*aspec.size;
|
|
161
|
966
|
162 /* unsilence audio, if callback is ready */
|
|
163 SDL_PauseAudio(0);
|
|
164
|
|
165 return 1;
|
|
166 }
|
|
167
|
|
168 // close audio device
|
|
169 static void uninit(){
|
|
170 SDL_CloseAudio();
|
972
|
171 SDL_QuitSubSystem(SDL_INIT_AUDIO);
|
966
|
172 }
|
|
173
|
|
174 // stop playing and empty buffers (for seeking/pause)
|
|
175 static void reset(){
|
972
|
176
|
|
177 /* Reset ring-buffer state */
|
|
178 buf_read=0;
|
|
179 buf_write=0;
|
|
180 buf_read_pos=0;
|
|
181 buf_write_pos=0;
|
|
182
|
|
183 full_buffers=0;
|
|
184 buffered_bytes=0;
|
966
|
185
|
|
186 }
|
|
187
|
|
188 // return: how many bytes can be played without blocking
|
|
189 static int get_space(){
|
972
|
190 return (NUM_BUFS-full_buffers)*BUFFSIZE - buf_write_pos;
|
966
|
191 }
|
|
192
|
|
193 // plays 'len' bytes of 'data'
|
|
194 // it should round it down to outburst*n
|
|
195 // return: number of bytes played
|
|
196 static int play(void* data,int len,int flags){
|
972
|
197
|
|
198 #if 0
|
|
199 int ret;
|
966
|
200
|
972
|
201 /* Audio locking prohibits call of outputaudio */
|
966
|
202 SDL_LockAudio();
|
972
|
203 // copy audio stream into ring-buffer
|
|
204 ret = write_buffer(data, len);
|
966
|
205 SDL_UnlockAudio();
|
|
206
|
972
|
207 return ret;
|
|
208 #else
|
|
209 return write_buffer(data, len);
|
|
210 #endif
|
966
|
211 }
|
|
212
|
|
213 // return: how many unplayed bytes are in the buffer
|
|
214 static int get_delay(){
|
974
|
215 return buffered_bytes + ao_buffersize;
|
966
|
216 }
|
|
217
|
|
218
|
|
219
|
|
220
|
|
221
|
|
222
|