git.sesse.net Git - vlc/blob - modules/gui/qnx/aout.c

   1 /*****************************************************************************
   2  * aout.c : QNX audio output
   3  *****************************************************************************
   4  * Copyright (C) 2000, 2001 VideoLAN
   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., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  * Preamble
  27  *****************************************************************************/
  28 #include <errno.h>                                                 /* ENOMEM */
  29 #include <string.h>                                            /* strerror() */
  30 #include <stdlib.h>                            /* calloc(), malloc(), free() */
  31
  32 #include <vlc/vlc.h>
  33
  34 #ifdef HAVE_ALLOCA_H
  35 #   include <alloca.h>
  36 #endif
  37
  38 #include <vlc/aout.h>
  39 #include "aout_internal.h"
  40
  41 #include <sys/asoundlib.h>
  42
  43 struct aout_sys_t
  44 {
  45     snd_pcm_t  * p_pcm_handle;
  46     int          i_card;
  47     int          i_device;
  48
  49     byte_t *     p_silent_buffer;
  50     vlc_bool_t   b_initialized;
  51 };
  52
  53 #define DEFAULT_FRAME_SIZE 2048
  54
  55 /*****************************************************************************
  56  * Local prototypes
  57  *****************************************************************************/
  58 int            E_(OpenAudio)    ( vlc_object_t *p_this );
  59 void           E_(CloseAudio)   ( vlc_object_t *p_this );
  60 static int     GetBufInfo       ( aout_instance_t * );
  61 static int     SetFormat        ( aout_instance_t * );
  62 static void    Play             ( aout_instance_t * );
  63 static int     QNXaoutThread    ( aout_instance_t * );
  64
  65 /*****************************************************************************
  66  * Open : creates a handle and opens an alsa device
  67  *****************************************************************************
  68  * This function opens an alsa device, through the alsa API
  69  *****************************************************************************/
  70 int E_(OpenAudio)( vlc_object_t *p_this )
  71 {
  72     aout_instance_t *p_aout = (aout_instance_t *)p_this;
  73     int i_ret;
  74
  75     /* allocate structure */
  76     p_aout->output.p_sys = malloc( sizeof( aout_sys_t ) );
  77     if( p_aout->output.p_sys == NULL )
  78     {
  79         msg_Err( p_aout, "out of memory" );
  80         return -1;
  81     }
  82
  83     /* open audio device */
  84     if( ( i_ret = snd_pcm_open_preferred( &p_aout->output.p_sys->p_pcm_handle,
  85                                           &p_aout->output.p_sys->i_card,
  86                                           &p_aout->output.p_sys->i_device,
  87                                           SND_PCM_OPEN_PLAYBACK ) ) < 0 )
  88     {
  89         msg_Err( p_aout, "unable to open audio device (%s)",
  90                          snd_strerror( i_ret ) );
  91         free( p_aout->output.p_sys );
  92         return -1;
  93     }
  94
  95     /* disable mmap */
  96     if( ( i_ret = snd_pcm_plugin_set_disable( p_aout->output.p_sys->p_pcm_handle,
  97                                               PLUGIN_DISABLE_MMAP ) ) < 0 )
  98     {
  99         msg_Err( p_aout, "unable to disable mmap (%s)", snd_strerror(i_ret) );
 100         E_(CloseAudio)( p_this );
 101         free( p_aout->output.p_sys );
 102         return -1;
 103     }
 104
 105     /* Create audio thread and wait for its readiness. */
 106     p_aout->output.p_sys->b_initialized = VLC_FALSE;
 107     if( vlc_thread_create( p_aout, "aout", QNXaoutThread, VLC_FALSE ) )
 108     {
 109         msg_Err( p_aout, "cannot create QNX audio thread (%s)", strerror(errno) );
 110         E_(CloseAudio)( p_this );
 111         free( p_aout->output.p_sys );
 112         return -1;
 113     }
 114
 115     p_aout->output.p_sys->p_silent_buffer = malloc( DEFAULT_FRAME_SIZE * 4 );
 116
 117     p_aout->output.pf_setformat = SetFormat;
 118     p_aout->output.pf_play = Play;
 119
 120     return( 0 );
 121 }
 122
 123 /*****************************************************************************
 124  * SetFormat : set the audio output format
 125  *****************************************************************************
 126  * This function prepares the device, sets the rate, format, the mode
 127  * ("play as soon as you have data"), and buffer information.
 128  *****************************************************************************/
 129 static int SetFormat( aout_instance_t *p_this )
 130 {
 131     int i_ret;
 132     int i_bytes_per_sample;
 133     snd_pcm_channel_info_t pi;
 134     snd_pcm_channel_params_t pp;
 135     aout_instance_t *p_aout = (aout_instance_t *)p_this;
 136
 137     p_aout->output.p_sys->b_initialized = VLC_FALSE;
 138
 139     memset( &pi, 0, sizeof(pi) );
 140     memset( &pp, 0, sizeof(pp) );
 141
 142     pi.channel = SND_PCM_CHANNEL_PLAYBACK;
 143     if( ( i_ret = snd_pcm_plugin_info( p_aout->output.p_sys->p_pcm_handle,
 144                                        &pi ) ) < 0 )
 145     {
 146         msg_Err( p_aout, "unable to get plugin info (%s)",
 147                          snd_strerror( i_ret ) );
 148         return -1;
 149     }
 150
 151     pp.mode       = SND_PCM_MODE_BLOCK;
 152     pp.channel    = SND_PCM_CHANNEL_PLAYBACK;
 153     pp.start_mode = SND_PCM_START_FULL;
 154     pp.stop_mode  = SND_PCM_STOP_STOP;
 155
 156     pp.buf.block.frags_max   = 3;
 157     pp.buf.block.frags_min   = 1;
 158
 159     pp.format.interleave     = 1;
 160     pp.format.rate           = p_aout->output.output.i_rate;
 161     pp.format.voices         = p_aout->output.output.i_channels;
 162
 163     p_aout->output.output.i_format = AOUT_FMT_S16_NE;
 164     p_aout->output.i_nb_samples = DEFAULT_FRAME_SIZE;
 165
 166     switch( p_aout->output.output.i_format )
 167     {
 168         case AOUT_FMT_S16_LE:
 169             pp.format.format = SND_PCM_SFMT_S16_LE;
 170             i_bytes_per_sample = 2;
 171             break;
 172
 173         default:
 174             pp.format.format = SND_PCM_SFMT_S16_BE;
 175             i_bytes_per_sample = 2;
 176             break;
 177     }
 178
 179     pp.buf.block.frag_size = p_aout->output.i_nb_samples *
 180                             p_aout->output.output.i_channels *
 181                             i_bytes_per_sample;
 182
 183     /* set parameters */
 184     if( ( i_ret = snd_pcm_plugin_params( p_aout->output.p_sys->p_pcm_handle,
 185                                          &pp ) ) < 0 )
 186     {
 187         msg_Err( p_aout, "unable to set parameters (%s)", snd_strerror(i_ret) );
 188         return -1;
 189     }
 190
 191     /* prepare channel */
 192     if( ( i_ret = snd_pcm_plugin_prepare( p_aout->output.p_sys->p_pcm_handle,
 193                                           SND_PCM_CHANNEL_PLAYBACK ) ) < 0 )
 194     {
 195         msg_Err( p_aout, "unable to prepare channel (%s)",
 196                          snd_strerror( i_ret ) );
 197         return -1;
 198     }
 199
 200     p_aout->output.p_sys->b_initialized = VLC_TRUE;
 201
 202     return( 0 );
 203 }
 204
 205 /*****************************************************************************
 206  * GetBufInfo: buffer status query
 207  *****************************************************************************
 208  * This function returns the number of used byte in the queue.
 209  * It also deals with errors : indeed if the device comes to run out
 210  * of data to play, it switches to the "underrun" status. It has to
 211  * be flushed and re-prepared
 212  *****************************************************************************/
 213 static int GetBufInfo( aout_instance_t *p_aout )
 214 {
 215     int i_ret;
 216     snd_pcm_channel_status_t status;
 217
 218     /* get current pcm status */
 219     memset( &status, 0, sizeof(status) );
 220     if( ( i_ret = snd_pcm_plugin_status( p_aout->output.p_sys->p_pcm_handle,
 221                                          &status ) ) < 0 )
 222     {
 223         msg_Err( p_aout, "unable to get device status (%s)",
 224                          snd_strerror( i_ret ) );
 225         return( -1 );
 226     }
 227
 228     /* check for underrun */
 229     switch( status.status )
 230     {
 231         case SND_PCM_STATUS_READY:
 232         case SND_PCM_STATUS_UNDERRUN:
 233             if( ( i_ret = snd_pcm_plugin_prepare( p_aout->output.p_sys->p_pcm_handle,
 234                                           SND_PCM_CHANNEL_PLAYBACK ) ) < 0 )
 235             {
 236                 msg_Err( p_aout, "unable to prepare channel (%s)",
 237                                  snd_strerror( i_ret ) );
 238             }
 239             break;
 240     }
 241
 242     return( status.count );
 243 }
 244
 245 /*****************************************************************************
 246  * Play : plays a sample
 247  *****************************************************************************
 248  * Plays a sample using the snd_pcm_write function from the alsa API
 249  *****************************************************************************/
 250 static void Play( aout_instance_t *p_aout )
 251 {
 252 }
 253
 254 /*****************************************************************************
 255  * CloseAudio: close the audio device
 256  *****************************************************************************/
 257 void E_(CloseAudio) ( vlc_object_t *p_this )
 258 {
 259     aout_instance_t *p_aout = (aout_instance_t *)p_this;
 260     int i_ret;
 261
 262     p_aout->b_die = 1;
 263     vlc_thread_join( p_aout );
 264
 265     if( ( i_ret = snd_pcm_close( p_aout->output.p_sys->p_pcm_handle ) ) < 0 )
 266     {
 267         msg_Err( p_aout, "unable to close audio device (%s)",
 268                          snd_strerror( i_ret ) );
 269     }
 270
 271     free( p_aout->output.p_sys->p_silent_buffer );
 272     free( p_aout->output.p_sys );
 273 }
 274
 275
 276 /*****************************************************************************
 277  * QNXaoutThread: asynchronous thread used to DMA the data to the device
 278  *****************************************************************************/
 279 static int QNXaoutThread( aout_instance_t * p_aout )
 280 {
 281     struct aout_sys_t * p_sys = p_aout->output.p_sys;
 282
 283     while ( !p_aout->b_die )
 284     {
 285         aout_buffer_t * p_buffer;
 286         int i_tmp, i_size;
 287         byte_t * p_bytes;
 288
 289         if( !p_sys->b_initialized )
 290         {
 291             msleep( THREAD_SLEEP );
 292             continue;
 293         }
 294
 295         if ( p_aout->output.output.i_format != AOUT_FMT_SPDIF )
 296         {
 297             mtime_t next_date = 0;
 298
 299             /* Get the presentation date of the next write() operation. It
 300              * is equal to the current date + duration of buffered samples.
 301              * Order is important here, since GetBufInfo is believed to take
 302              * more time than mdate(). */
 303             next_date = (mtime_t)GetBufInfo( p_aout ) * 1000000
 304                       / p_aout->output.output.i_bytes_per_frame
 305                       / p_aout->output.output.i_rate
 306                       * p_aout->output.output.i_frame_length;
 307             next_date += mdate();
 308
 309             p_buffer = aout_OutputNextBuffer( p_aout, next_date, VLC_FALSE );
 310         }
 311         else
 312         {
 313             p_buffer = aout_OutputNextBuffer( p_aout, 0, VLC_TRUE );
 314         }
 315
 316         if ( p_buffer != NULL )
 317         {
 318             p_bytes = p_buffer->p_buffer;
 319             i_size = p_buffer->i_nb_bytes;
 320         }
 321         else
 322         {
 323             i_size = DEFAULT_FRAME_SIZE / p_aout->output.output.i_frame_length
 324                       * p_aout->output.output.i_bytes_per_frame;
 325             p_bytes = p_aout->output.p_sys->p_silent_buffer;
 326             memset( p_bytes, 0, i_size );
 327         }
 328
 329         i_tmp = snd_pcm_plugin_write( p_aout->output.p_sys->p_pcm_handle,
 330                                         (void *) p_bytes,
 331                                         (size_t) i_size );
 332
 333         if( i_tmp < 0 )
 334         {
 335             msg_Err( p_aout, "write failed (%s)", strerror(errno) );
 336         }
 337
 338         if ( p_buffer != NULL )
 339         {
 340             aout_BufferFree( p_buffer );
 341         }
 342     }
 343
 344     return 0;
 345 }
 346