3f86707bb2ed144a49f8fb79f4a72d0293f8e7e5
[vlc.git] / modules / gui / qnx / aout.c
1 /*****************************************************************************
2  * aout.c : QNX audio output
3  *****************************************************************************
4  * Copyright (C) 2000, 2001 the VideoLAN team
5  *
6  * Authors: Henri Fallon <henri@videolan.org>
7  *          Jon Lech Johansen <jon-vl@nanocrew.net>
8  *          Pascal Levesque <pascal.levesque@mindready.com>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24
25 /*****************************************************************************
26  * Preamble
27  *****************************************************************************/
28 #include <errno.h>                                                 /* ENOMEM */
29
30 #ifdef HAVE_CONFIG_H
31 # include "config.h"
32 #endif
33
34 #include <vlc_common.h>
35
36 #ifdef HAVE_ALLOCA_H
37 #   include <alloca.h>
38 #endif
39
40 #include <vlc_aout.h>
41
42 #include <sys/asoundlib.h>
43
44 struct aout_sys_t
45 {
46     snd_pcm_t  * p_pcm_handle;
47     int          i_card;
48     int          i_device;
49
50     uint8_t *    p_silent_buffer;
51 };
52
53 #define DEFAULT_FRAME_SIZE 2048
54
55 /*****************************************************************************
56  * Local prototypes
57  *****************************************************************************/
58 int            OpenAudio    ( vlc_object_t *p_this );
59 void           CloseAudio   ( vlc_object_t *p_this );
60 static int     GetBufInfo       ( aout_instance_t * );
61 static void    Play             ( aout_instance_t * );
62 static int     QNXaoutThread    ( aout_instance_t * );
63
64 /*****************************************************************************
65  * Open : creates a handle and opens an alsa device
66  *****************************************************************************
67  * This function opens an alsa device, through the alsa API
68  *****************************************************************************/
69 int OpenAudio( vlc_object_t *p_this )
70 {
71     aout_instance_t *p_aout = (aout_instance_t *)p_this;
72     int i_ret;
73     int i_bytes_per_sample;
74     int i_nb_channels;
75     snd_pcm_channel_info_t pi;
76     snd_pcm_channel_params_t pp;
77     aout_instance_t *p_aout = (aout_instance_t *)p_this;
78
79     /* allocate structure */
80     p_aout->output.p_sys = malloc( sizeof( aout_sys_t ) );
81     if( p_aout->output.p_sys == NULL )
82     {
83         msg_Err( p_aout, "out of memory" );
84         return -1;
85     }
86
87     /* open audio device */
88     if( ( i_ret = snd_pcm_open_preferred( &p_aout->output.p_sys->p_pcm_handle,
89                                           &p_aout->output.p_sys->i_card,
90                                           &p_aout->output.p_sys->i_device,
91                                           SND_PCM_OPEN_PLAYBACK ) ) < 0 )
92     {
93         msg_Err( p_aout, "unable to open audio device (%s)",
94                          snd_strerror( i_ret ) );
95         free( p_aout->output.p_sys );
96         return -1;
97     }
98
99     /* disable mmap */
100     if( ( i_ret = snd_pcm_plugin_set_disable( p_aout->output.p_sys->p_pcm_handle,
101                                               PLUGIN_DISABLE_MMAP ) ) < 0 )
102     {
103         msg_Err( p_aout, "unable to disable mmap (%s)", snd_strerror(i_ret) );
104         CloseAudio( p_this );
105         free( p_aout->output.p_sys );
106         return -1;
107     }
108
109     p_aout->output.p_sys->p_silent_buffer = malloc( DEFAULT_FRAME_SIZE * 4 );
110     p_aout->output.pf_play = Play;
111     aout_VolumeSoftInit( p_aout );
112
113     memset( &pi, 0, sizeof(pi) );
114     memset( &pp, 0, sizeof(pp) );
115
116     pi.channel = SND_PCM_CHANNEL_PLAYBACK;
117     if( ( i_ret = snd_pcm_plugin_info( p_aout->output.p_sys->p_pcm_handle,
118                                        &pi ) ) < 0 )
119     {
120         msg_Err( p_aout, "unable to get plugin info (%s)",
121                          snd_strerror( i_ret ) );
122         CloseAudio( p_this );
123         free( p_aout->output.p_sys );
124         return -1;
125     }
126
127     pp.mode       = SND_PCM_MODE_BLOCK;
128     pp.channel    = SND_PCM_CHANNEL_PLAYBACK;
129     pp.start_mode = SND_PCM_START_FULL;
130     pp.stop_mode  = SND_PCM_STOP_STOP;
131
132     pp.buf.block.frags_max   = 3;
133     pp.buf.block.frags_min   = 1;
134
135     pp.format.interleave     = 1;
136     pp.format.rate           = p_aout->output.output.i_rate;
137
138     i_nb_channels = aout_FormatNbChannels( &p_aout->output.output );
139     if ( i_nb_channels > 2 )
140     {
141         /* I don't know if QNX supports more than two channels. */
142         i_nb_channels = 2;
143         p_aout->output.output.i_channels = AOUT_CHAN_STEREO;
144     }
145     pp.format.voices         = i_nb_channels;
146
147     p_aout->output.output.i_format = AOUT_FMT_S16_NE;
148     p_aout->output.i_nb_samples = DEFAULT_FRAME_SIZE;
149     pp.format.format = SND_PCM_SFMT_S16;
150     i_bytes_per_sample = 2;
151
152     pp.buf.block.frag_size = p_aout->output.i_nb_samples *
153                             p_aout->output.output.i_channels *
154                             i_bytes_per_sample;
155
156     /* set parameters */
157     if( ( i_ret = snd_pcm_plugin_params( p_aout->output.p_sys->p_pcm_handle,
158                                          &pp ) ) < 0 )
159     {
160         msg_Err( p_aout, "unable to set parameters (%s)", snd_strerror(i_ret) );
161         CloseAudio( p_this );
162         free( p_aout->output.p_sys );
163         return -1;
164     }
165
166     /* prepare channel */
167     if( ( i_ret = snd_pcm_plugin_prepare( p_aout->output.p_sys->p_pcm_handle,
168                                           SND_PCM_CHANNEL_PLAYBACK ) ) < 0 )
169     {
170         msg_Err( p_aout, "unable to prepare channel (%s)",
171                          snd_strerror( i_ret ) );
172         CloseAudio( p_this );
173         free( p_aout->output.p_sys );
174         return -1;
175     }
176
177     /* Create audio thread and wait for its readiness. */
178     if( vlc_thread_create( p_aout, "aout", QNXaoutThread,
179                            VLC_THREAD_PRIORITY_OUTPUT, false ) )
180     {
181         msg_Err( p_aout, "cannot create QNX audio thread (%m)" );
182         CloseAudio( p_this );
183         free( p_aout->output.p_sys );
184         return -1;
185     }
186
187     return( 0 );
188 }
189
190 /*****************************************************************************
191  * GetBufInfo: buffer status query
192  *****************************************************************************
193  * This function returns the number of used byte in the queue.
194  * It also deals with errors : indeed if the device comes to run out
195  * of data to play, it switches to the "underrun" status. It has to
196  * be flushed and re-prepared
197  *****************************************************************************/
198 static int GetBufInfo( aout_instance_t *p_aout )
199 {
200     int i_ret;
201     snd_pcm_channel_status_t status;
202
203     /* get current pcm status */
204     memset( &status, 0, sizeof(status) );
205     if( ( i_ret = snd_pcm_plugin_status( p_aout->output.p_sys->p_pcm_handle,
206                                          &status ) ) < 0 )
207     {
208         msg_Err( p_aout, "unable to get device status (%s)",
209                          snd_strerror( i_ret ) );
210         return( -1 );
211     }
212
213     /* check for underrun */
214     switch( status.status )
215     {
216         case SND_PCM_STATUS_READY:
217         case SND_PCM_STATUS_UNDERRUN:
218             if( ( i_ret = snd_pcm_plugin_prepare( p_aout->output.p_sys->p_pcm_handle,
219                                           SND_PCM_CHANNEL_PLAYBACK ) ) < 0 )
220             {
221                 msg_Err( p_aout, "unable to prepare channel (%s)",
222                                  snd_strerror( i_ret ) );
223             }
224             break;
225     }
226
227     return( status.count );
228 }
229
230 /*****************************************************************************
231  * Play : plays a sample
232  *****************************************************************************
233  * Plays a sample using the snd_pcm_write function from the alsa API
234  *****************************************************************************/
235 static void Play( aout_instance_t *p_aout )
236 {
237 }
238
239 /*****************************************************************************
240  * CloseAudio: close the audio device
241  *****************************************************************************/
242 void CloseAudio ( vlc_object_t *p_this )
243 {
244     aout_instance_t *p_aout = (aout_instance_t *)p_this;
245     int i_ret;
246
247     vlc_object_kill( p_aout );
248     vlc_thread_join( p_aout );
249
250     if( ( i_ret = snd_pcm_close( p_aout->output.p_sys->p_pcm_handle ) ) < 0 )
251     {
252         msg_Err( p_aout, "unable to close audio device (%s)",
253                          snd_strerror( i_ret ) );
254     }
255
256     free( p_aout->output.p_sys->p_silent_buffer );
257     free( p_aout->output.p_sys );
258 }
259
260
261 /*****************************************************************************
262  * QNXaoutThread: asynchronous thread used to DMA the data to the device
263  *****************************************************************************/
264 static int QNXaoutThread( aout_instance_t * p_aout )
265 {
266     struct aout_sys_t * p_sys = p_aout->output.p_sys;
267
268     while ( vlc_object_alive (p_aout) )
269     {
270         aout_buffer_t * p_buffer;
271         int i_tmp, i_size;
272         uint8_t * p_bytes;
273
274         if ( p_aout->output.output.i_format != VLC_FOURCC('s','p','d','i') )
275         {
276             mtime_t next_date = 0;
277
278             /* Get the presentation date of the next write() operation. It
279              * is equal to the current date + duration of buffered samples.
280              * Order is important here, since GetBufInfo is believed to take
281              * more time than mdate(). */
282             next_date = (mtime_t)GetBufInfo( p_aout ) * 1000000
283                       / p_aout->output.output.i_bytes_per_frame
284                       / p_aout->output.output.i_rate
285                       * p_aout->output.output.i_frame_length;
286             next_date += mdate();
287
288             p_buffer = aout_OutputNextBuffer( p_aout, next_date, false );
289         }
290         else
291         {
292             p_buffer = aout_OutputNextBuffer( p_aout, 0, true );
293         }
294
295         if ( p_buffer != NULL )
296         {
297             p_bytes = p_buffer->p_buffer;
298             i_size = p_buffer->i_nb_bytes;
299         }
300         else
301         {
302             i_size = DEFAULT_FRAME_SIZE / p_aout->output.output.i_frame_length
303                       * p_aout->output.output.i_bytes_per_frame;
304             p_bytes = p_aout->output.p_sys->p_silent_buffer;
305             memset( p_bytes, 0, i_size );
306         }
307
308         i_tmp = snd_pcm_plugin_write( p_aout->output.p_sys->p_pcm_handle,
309                                         (void *) p_bytes,
310                                         (size_t) i_size );
311
312         if( i_tmp < 0 )
313         {
314             msg_Err( p_aout, "write failed (%m)" );
315         }
316
317         if ( p_buffer != NULL )
318         {
319             aout_BufferFree( p_buffer );
320         }
321     }
322
323     return 0;
324 }
325