LCOV - code coverage report
Current view: directory - media/libsydneyaudio/src - sydney_audio_alsa.c (source / functions) Found Hit Coverage
Test: app.info Lines: 258 0 0.0 %
Date: 2012-06-02 Functions: 68 0 0.0 %

       1                 : /* ***** BEGIN LICENSE BLOCK *****
       2                 :  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
       3                 :  *
       4                 :  * The contents of this file are subject to the Mozilla Public License Version
       5                 :  * 1.1 (the "License"); you may not use this file except in compliance with
       6                 :  * the License. You may obtain a copy of the License at
       7                 :  * http://www.mozilla.org/MPL/
       8                 :  *
       9                 :  * Software distributed under the License is distributed on an "AS IS" basis,
      10                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
      11                 :  * for the specific language governing rights and limitations under the
      12                 :  * License.
      13                 :  *
      14                 :  * The Initial Developer of the Original Code is
      15                 :  * CSIRO
      16                 :  * Portions created by the Initial Developer are Copyright (C) 2007
      17                 :  * the Initial Developer. All Rights Reserved.
      18                 :  *
      19                 :  * Contributor(s): Michael Martin
      20                 :  *                 Chris Double (chris.double@double.co.nz)
      21                 :  *
      22                 :  * Alternatively, the contents of this file may be used under the terms of
      23                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
      24                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
      25                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
      26                 :  * of those above. If you wish to allow use of your version of this file only
      27                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
      28                 :  * use your version of this file under the terms of the MPL, indicate your
      29                 :  * decision by deleting the provisions above and replace them with the notice
      30                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
      31                 :  * the provisions above, a recipient may use your version of this file under
      32                 :  * the terms of any one of the MPL, the GPL or the LGPL.
      33                 :  *
      34                 :  * ***** END LICENSE BLOCK ***** *
      35                 :  */
      36                 : #include <pthread.h>
      37                 : #include <stdlib.h>
      38                 : #include <alsa/asoundlib.h>
      39                 : #include "sydney_audio.h"
      40                 : 
      41                 : /* ALSA implementation based heavily on sydney_audio_mac.c */
      42                 : 
      43                 : pthread_mutex_t sa_alsa_mutex = PTHREAD_MUTEX_INITIALIZER;
      44                 : 
      45                 : struct sa_stream {
      46                 :   snd_pcm_t*        output_unit;
      47                 :   int64_t           bytes_written;
      48                 :   int64_t           last_position;
      49                 : 
      50                 :   /* audio format info */
      51                 :   unsigned int      rate;
      52                 :   unsigned int      n_channels;
      53                 : 
      54                 :   /* work around bug 573924 */
      55                 :   int               pulseaudio;
      56                 :   int               resumed;
      57                 : };
      58                 : 
      59                 : /*
      60                 :  * -----------------------------------------------------------------------------
      61                 :  *  Error Handler to prevent output to stderr
      62                 :  *  ----------------------------------------------------------------------------
      63                 :  */
      64                 : static void
      65               0 : quiet_error_handler(const char* file,
      66                 :                     int         line,
      67                 :                     const char* function,
      68                 :                     int         err,
      69                 :                     const char* format,
      70                 :                     ...)
      71                 : {
      72               0 : }
      73                 : 
      74                 : /*
      75                 :  * -----------------------------------------------------------------------------
      76                 :  * Startup and shutdown functions
      77                 :  * -----------------------------------------------------------------------------
      78                 :  */
      79                 : 
      80                 : int
      81               0 : sa_stream_create_pcm(
      82                 :   sa_stream_t      ** _s,
      83                 :   const char        * client_name,
      84                 :   sa_mode_t           mode,
      85                 :   sa_pcm_format_t     format,
      86                 :   unsigned  int       rate,
      87                 :   unsigned  int       n_channels
      88                 : ) {
      89               0 :   sa_stream_t   * s = 0;
      90                 : 
      91                 :   /*
      92                 :    * Make sure we return a NULL stream pointer on failure.
      93                 :    */
      94               0 :   if (_s == NULL) {
      95               0 :     return SA_ERROR_INVALID;
      96                 :   }
      97               0 :   *_s = NULL;
      98                 : 
      99               0 :   if (mode != SA_MODE_WRONLY) {
     100               0 :     return SA_ERROR_NOT_SUPPORTED;
     101                 :   }
     102               0 :   if (format != SA_PCM_FORMAT_S16_NE) {
     103               0 :     return SA_ERROR_NOT_SUPPORTED;
     104                 :   }
     105                 : 
     106                 :   /*
     107                 :    * Allocate the instance and required resources.
     108                 :    */
     109               0 :   if ((s = malloc(sizeof(sa_stream_t))) == NULL) {
     110               0 :     return SA_ERROR_OOM;
     111                 :   }
     112                 : 
     113               0 :   s->output_unit  = NULL;
     114               0 :   s->bytes_written = 0;
     115               0 :   s->last_position = 0;
     116               0 :   s->rate         = rate;
     117               0 :   s->n_channels   = n_channels;
     118               0 :   s->pulseaudio   = 0;
     119               0 :   s->resumed      = 0;
     120                 : 
     121               0 :   *_s = s;
     122               0 :   return SA_SUCCESS;
     123                 : }
     124                 : 
     125                 : 
     126                 : int
     127               0 : sa_stream_open(sa_stream_t *s) {
     128                 :   snd_output_t* out;
     129                 :   char* buf;
     130                 :   size_t bufsz;
     131                 :   snd_pcm_hw_params_t* hwparams;
     132                 :   snd_pcm_sw_params_t* swparams;
     133                 :   int dir;
     134                 :   snd_pcm_uframes_t period;
     135                 : 
     136               0 :   if (s == NULL) {
     137               0 :     return SA_ERROR_NO_INIT;
     138                 :   }
     139               0 :   if (s->output_unit != NULL) {
     140               0 :     return SA_ERROR_INVALID;
     141                 :   }
     142                 : 
     143               0 :   pthread_mutex_lock(&sa_alsa_mutex);
     144                 : 
     145                 :   /* Turn off debug output to stderr */
     146               0 :   snd_lib_error_set_handler(quiet_error_handler);
     147                 : 
     148               0 :   if (snd_pcm_open(&s->output_unit, 
     149                 :                    "default", 
     150                 :                    SND_PCM_STREAM_PLAYBACK, 
     151                 :                    0) < 0) {
     152               0 :     pthread_mutex_unlock(&sa_alsa_mutex);
     153               0 :     return SA_ERROR_NO_DEVICE;
     154                 :   }
     155                 :   
     156               0 :   if (snd_pcm_set_params(s->output_unit,
     157                 : #ifdef SA_LITTLE_ENDIAN
     158                 :                          SND_PCM_FORMAT_S16_LE,
     159                 : #else
     160                 :                          SND_PCM_FORMAT_S16_BE,
     161                 : #endif
     162                 :                          SND_PCM_ACCESS_RW_INTERLEAVED,
     163                 :                          s->n_channels,
     164                 :                          s->rate,
     165                 :                          1,
     166                 :                          500000) < 0) {
     167               0 :     snd_pcm_close(s->output_unit);
     168               0 :     s->output_unit = NULL;
     169               0 :     pthread_mutex_unlock(&sa_alsa_mutex);
     170               0 :     return SA_ERROR_NOT_SUPPORTED;
     171                 :   }
     172                 :   
     173                 :   /* ugly alsa-pulse plugin detection */
     174               0 :   snd_output_buffer_open(&out);
     175               0 :   snd_pcm_dump(s->output_unit, out);
     176               0 :   bufsz = snd_output_buffer_string(out, &buf);
     177               0 :   if (strncmp(buf, "ALSA <-> PulseAudio PCM I/O Plugin", bufsz) > 0 ) {
     178               0 :     s->pulseaudio = 1;
     179                 :   }
     180               0 :   snd_output_close(out);
     181                 : 
     182               0 :   snd_pcm_hw_params_alloca(&hwparams);
     183               0 :   snd_pcm_hw_params_current(s->output_unit, hwparams);
     184               0 :   snd_pcm_hw_params_get_period_size(hwparams, &period, &dir);
     185                 : 
     186               0 :   pthread_mutex_unlock(&sa_alsa_mutex);
     187                 : 
     188               0 :   return SA_SUCCESS;
     189                 : }
     190                 : 
     191                 : 
     192                 : int
     193               0 : sa_stream_get_min_write(sa_stream_t *s, size_t *size) {
     194                 :   int r;
     195                 :   snd_pcm_uframes_t threshold;
     196                 :   snd_pcm_sw_params_t* swparams;
     197               0 :   if (s == NULL || s->output_unit == NULL) {
     198               0 :     return SA_ERROR_NO_INIT;
     199                 :   }
     200               0 :   snd_pcm_sw_params_alloca(&swparams);
     201               0 :   snd_pcm_sw_params_current(s->output_unit, swparams);
     202               0 :   r = snd_pcm_sw_params_get_start_threshold(swparams, &threshold);
     203               0 :   if (r < 0) {
     204               0 :     return SA_ERROR_NO_INIT;
     205                 :   }
     206               0 :   *size = snd_pcm_frames_to_bytes(s->output_unit, threshold);
     207                 : 
     208               0 :   return SA_SUCCESS;
     209                 : }
     210                 : 
     211                 : 
     212                 : int
     213               0 : sa_stream_destroy(sa_stream_t *s) {
     214               0 :   int result = SA_SUCCESS;
     215                 : 
     216               0 :   if (s == NULL) {
     217               0 :     return result;
     218                 :   }
     219                 :   /*
     220                 :    * Shut down the audio output device.
     221                 :    */
     222               0 :   if (s->output_unit != NULL) {
     223               0 :     pthread_mutex_lock(&sa_alsa_mutex);
     224               0 :     if (snd_pcm_close(s->output_unit) < 0) {
     225               0 :       result = SA_ERROR_SYSTEM;
     226                 :     }
     227               0 :     pthread_mutex_unlock(&sa_alsa_mutex);
     228                 :   }
     229               0 :   free(s);
     230               0 :   return result;
     231                 : }
     232                 : 
     233                 : 
     234                 : 
     235                 : /*
     236                 :  * -----------------------------------------------------------------------------
     237                 :  * Data read and write functions
     238                 :  * -----------------------------------------------------------------------------
     239                 :  */
     240                 : 
     241                 : int
     242               0 : sa_stream_write(sa_stream_t *s, const void *data, size_t nbytes) {
     243                 :   snd_pcm_sframes_t frames, nframes, avail;
     244                 : 
     245               0 :   if (s == NULL || s->output_unit == NULL) {
     246               0 :     return SA_ERROR_NO_INIT;
     247                 :   }
     248               0 :   if (nbytes == 0) {
     249               0 :     return SA_SUCCESS;
     250                 :   }
     251                 : 
     252               0 :   nframes = snd_pcm_bytes_to_frames(s->output_unit, nbytes);
     253               0 :   while(nframes>0) {
     254               0 :     if (s->resumed) {
     255               0 :       avail = snd_pcm_avail_update(s->output_unit);
     256               0 :       frames = snd_pcm_writei(s->output_unit, data, nframes > avail ? avail : nframes);
     257               0 :       avail = snd_pcm_avail_update(s->output_unit);
     258               0 :       s->resumed = avail != 0;
     259                 :     } else {
     260               0 :       avail = snd_pcm_avail_update(s->output_unit);
     261               0 :       avail = avail < 64 ? 64 : avail;
     262               0 :       frames = snd_pcm_writei(s->output_unit, data, nframes > avail ? avail : nframes);
     263                 :     }
     264               0 :     if (frames < 0) {
     265               0 :       int r = snd_pcm_recover(s->output_unit, frames, 1);
     266               0 :       if (r < 0) {
     267               0 :         return SA_ERROR_SYSTEM;
     268                 :       }
     269                 :     } else {
     270               0 :       size_t bytes = snd_pcm_frames_to_bytes(s->output_unit, frames);
     271               0 :       nframes -= frames;
     272               0 :       data = ((unsigned char *)data) + bytes;
     273               0 :       s->bytes_written += bytes;
     274                 :     }
     275                 :   }
     276                 : 
     277               0 :   return SA_SUCCESS;
     278                 : }
     279                 : 
     280                 : /*
     281                 :  * -----------------------------------------------------------------------------
     282                 :  * General query and support functions
     283                 :  * -----------------------------------------------------------------------------
     284                 :  */
     285                 : 
     286                 : int
     287               0 : sa_stream_get_write_size(sa_stream_t *s, size_t *size) {
     288                 :   snd_pcm_sframes_t avail;
     289                 : 
     290               0 :   if (s == NULL || s->output_unit == NULL) {
     291               0 :     return SA_ERROR_NO_INIT;
     292                 :   }
     293                 : 
     294                 :   do {
     295               0 :     avail = snd_pcm_avail_update(s->output_unit);
     296               0 :     if (avail < 0) {
     297               0 :       int r = snd_pcm_recover(s->output_unit, avail, 1);
     298               0 :       if (r < 0) {
     299               0 :         return SA_ERROR_SYSTEM;
     300                 :       }
     301               0 :       continue;
     302                 :     }
     303                 :     break;
     304               0 :   } while (1);
     305                 : 
     306               0 :   *size = snd_pcm_frames_to_bytes(s->output_unit, avail);
     307                 : 
     308               0 :   return SA_SUCCESS;
     309                 : }
     310                 : 
     311                 : int
     312               0 : sa_stream_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos) {
     313                 :   snd_pcm_sframes_t delay;
     314                 :   
     315               0 :   if (s == NULL || s->output_unit == NULL) {
     316               0 :     return SA_ERROR_NO_INIT;
     317                 :   }
     318                 : 
     319               0 :   if (position != SA_POSITION_WRITE_SOFTWARE) {
     320               0 :     return SA_ERROR_NOT_SUPPORTED;
     321                 :   }
     322                 : 
     323               0 :   if (snd_pcm_state(s->output_unit) != SND_PCM_STATE_RUNNING) {
     324               0 :     *pos = s->last_position;
     325               0 :     return SA_SUCCESS;
     326                 :   }
     327                 : 
     328               0 :   if (snd_pcm_delay(s->output_unit, &delay) != 0) {
     329               0 :     return SA_ERROR_SYSTEM;
     330                 :   }
     331                 : 
     332                 :   /* delay means audio is 'x' frames behind what we've written. We need to
     333                 :      subtract the delay from the data written to return the actual bytes played.
     334                 : 
     335                 :      due to buffering, the delay can be larger than the amount we've
     336                 :      written--in this case, report position as zero. */
     337               0 :   *pos = s->bytes_written;
     338               0 :   if (*pos >= snd_pcm_frames_to_bytes(s->output_unit, delay)) {
     339               0 :     *pos -= snd_pcm_frames_to_bytes(s->output_unit, delay);
     340                 :   } else {
     341               0 :     *pos = 0;
     342                 :   }
     343               0 :   s->last_position = *pos;
     344                 : 
     345               0 :   return SA_SUCCESS;
     346                 : }
     347                 : 
     348                 : 
     349                 : int
     350               0 : sa_stream_pause(sa_stream_t *s) {
     351                 : 
     352               0 :   if (s == NULL || s->output_unit == NULL) {
     353               0 :     return SA_ERROR_NO_INIT;
     354                 :   }
     355                 : 
     356               0 :   if (snd_pcm_pause(s->output_unit, 1) != 0)
     357               0 :     return SA_ERROR_NOT_SUPPORTED;
     358                 : 
     359               0 :   return SA_SUCCESS;
     360                 : }
     361                 : 
     362                 : 
     363                 : int
     364               0 : sa_stream_resume(sa_stream_t *s) {
     365                 : 
     366               0 :   if (s == NULL || s->output_unit == NULL) {
     367               0 :     return SA_ERROR_NO_INIT;
     368                 :   }
     369                 : 
     370               0 :   if (s->pulseaudio) {
     371               0 :     s->resumed = 1;
     372                 :   }
     373                 : 
     374               0 :   if (snd_pcm_pause(s->output_unit, 0) != 0)
     375               0 :     return SA_ERROR_NOT_SUPPORTED;
     376               0 :   return SA_SUCCESS;
     377                 : }
     378                 : 
     379                 : 
     380                 : int
     381               0 : sa_stream_drain(sa_stream_t *s)
     382                 : {
     383               0 :   if (s == NULL || s->output_unit == NULL) {
     384               0 :     return SA_ERROR_NO_INIT;
     385                 :   }
     386                 : 
     387               0 :   if (snd_pcm_state(s->output_unit) == SND_PCM_STATE_PREPARED) {
     388               0 :     size_t min_samples = 0;
     389               0 :     size_t min_bytes = 0;
     390                 :     void *buf;
     391                 : 
     392               0 :     if (sa_stream_get_min_write(s, &min_samples) < 0)
     393               0 :       return SA_ERROR_SYSTEM;
     394               0 :     min_bytes = snd_pcm_frames_to_bytes(s->output_unit, min_samples);    
     395                 : 
     396               0 :     buf = malloc(min_bytes);
     397               0 :     if (!buf)
     398               0 :       return SA_ERROR_SYSTEM;
     399               0 :     memset(buf, 0, min_bytes);
     400               0 :     sa_stream_write(s, buf, min_bytes);
     401               0 :     free(buf);
     402                 :   }
     403                 : 
     404               0 :   if (snd_pcm_state(s->output_unit) != SND_PCM_STATE_RUNNING) {
     405               0 :     return SA_ERROR_INVALID;
     406                 :   }
     407               0 :   snd_pcm_drain(s->output_unit);
     408               0 :   return SA_SUCCESS;
     409                 : }
     410                 : 
     411                 : 
     412                 : 
     413                 : /*
     414                 :  * -----------------------------------------------------------------------------
     415                 :  * Extension functions
     416                 :  * -----------------------------------------------------------------------------
     417                 :  */
     418                 : 
     419                 : int
     420               0 : sa_stream_set_volume_abs(sa_stream_t *s, float vol) {
     421               0 :   snd_mixer_t* mixer = 0;
     422               0 :   snd_mixer_elem_t* elem = 0;
     423               0 :   if (s == NULL || s->output_unit == NULL) {
     424               0 :     return SA_ERROR_NO_INIT;
     425                 :   }
     426                 : 
     427               0 :   if (snd_mixer_open(&mixer, 0) < 0) {
     428               0 :     return SA_ERROR_SYSTEM;
     429                 :   }
     430                 : 
     431               0 :   if (snd_mixer_attach(mixer, "default") < 0) {
     432               0 :     snd_mixer_close(mixer);
     433               0 :     return SA_ERROR_SYSTEM;
     434                 :   }
     435                 : 
     436               0 :   if (snd_mixer_selem_register(mixer, NULL, NULL) < 0) {
     437               0 :     snd_mixer_close(mixer);
     438               0 :     return SA_ERROR_SYSTEM;
     439                 :   }
     440                 : 
     441               0 :   if (snd_mixer_load(mixer) < 0) {
     442               0 :     snd_mixer_close(mixer);
     443               0 :     return SA_ERROR_SYSTEM;
     444                 :   }
     445                 : 
     446                 : #if 0
     447                 :   snd_mixer_elem_t* elem = 0;
     448                 :   for (elem = snd_mixer_first_elem(mixer); elem != NULL; elem = snd_mixer_elem_next(elem)) {
     449                 :     if (snd_mixer_selem_has_playback_volume(elem)) {
     450                 :       printf("Playback %s\n", snd_mixer_selem_get_name(elem));
     451                 :     }
     452                 :     else {
     453                 :       printf("No Playback: %s\n", snd_mixer_selem_get_name(elem));
     454                 :     }
     455                 :   }
     456                 : #endif
     457               0 :   elem = snd_mixer_first_elem(mixer);
     458               0 :   if (elem && snd_mixer_selem_has_playback_volume(elem)) {
     459               0 :     long min = 0;
     460               0 :     long max = 0;
     461               0 :     if (snd_mixer_selem_get_playback_volume_range(elem, &min, &max) >= 0) {
     462               0 :       snd_mixer_selem_set_playback_volume_all(elem, (max-min)*vol + min);
     463                 :     } 
     464                 :   }
     465               0 :   snd_mixer_close(mixer);
     466                 : 
     467               0 :   return SA_SUCCESS;
     468                 : }
     469                 : 
     470                 : 
     471                 : int
     472               0 : sa_stream_get_volume_abs(sa_stream_t *s, float *vol) {
     473               0 :   snd_mixer_t* mixer = 0;
     474               0 :   snd_mixer_elem_t* elem = 0;
     475               0 :   long value = 0;
     476                 : 
     477               0 :   if (s == NULL || s->output_unit == NULL) {
     478               0 :     return SA_ERROR_NO_INIT;
     479                 :   }
     480                 : 
     481               0 :   if (snd_mixer_open(&mixer, 0) < 0) {
     482               0 :     return SA_ERROR_SYSTEM;
     483                 :   }
     484                 : 
     485               0 :   if (snd_mixer_attach(mixer, "default") < 0) {
     486               0 :     snd_mixer_close(mixer);
     487               0 :     return SA_ERROR_SYSTEM;
     488                 :   }
     489                 : 
     490               0 :   if (snd_mixer_selem_register(mixer, NULL, NULL) < 0) {
     491               0 :     snd_mixer_close(mixer);
     492               0 :     return SA_ERROR_SYSTEM;
     493                 :   }
     494                 : 
     495               0 :   if (snd_mixer_load(mixer) < 0) {
     496               0 :     snd_mixer_close(mixer);
     497               0 :     return SA_ERROR_SYSTEM;
     498                 :   }
     499                 : 
     500               0 :   elem = snd_mixer_first_elem(mixer);
     501               0 :   if (elem && snd_mixer_selem_get_playback_volume(elem, 0, &value) >= 0) {
     502               0 :     long min = 0;
     503               0 :     long max = 0;
     504               0 :     if (snd_mixer_selem_get_playback_volume_range(elem, &min, &max) >= 0) {
     505               0 :       *vol = (float)(value-min)/(float)(max-min);
     506                 :     } 
     507                 :   }
     508               0 :   snd_mixer_close(mixer);
     509                 : 
     510               0 :   return SA_SUCCESS;
     511                 : }
     512                 : 
     513                 : 
     514                 : 
     515                 : /*
     516                 :  * -----------------------------------------------------------------------------
     517                 :  * Unsupported functions
     518                 :  * -----------------------------------------------------------------------------
     519                 :  */
     520                 : #define UNSUPPORTED(func)   func { return SA_ERROR_NOT_SUPPORTED; }
     521                 : 
     522               0 : UNSUPPORTED(int sa_stream_create_opaque(sa_stream_t **s, const char *client_name, sa_mode_t mode, const char *codec))
     523               0 : UNSUPPORTED(int sa_stream_set_write_lower_watermark(sa_stream_t *s, size_t size))
     524               0 : UNSUPPORTED(int sa_stream_set_read_lower_watermark(sa_stream_t *s, size_t size))
     525               0 : UNSUPPORTED(int sa_stream_set_write_upper_watermark(sa_stream_t *s, size_t size))
     526               0 : UNSUPPORTED(int sa_stream_set_read_upper_watermark(sa_stream_t *s, size_t size))
     527               0 : UNSUPPORTED(int sa_stream_set_channel_map(sa_stream_t *s, const sa_channel_t map[], unsigned int n))
     528               0 : UNSUPPORTED(int sa_stream_set_xrun_mode(sa_stream_t *s, sa_xrun_mode_t mode))
     529               0 : UNSUPPORTED(int sa_stream_set_non_interleaved(sa_stream_t *s, int enable))
     530               0 : UNSUPPORTED(int sa_stream_set_dynamic_rate(sa_stream_t *s, int enable))
     531               0 : UNSUPPORTED(int sa_stream_set_driver(sa_stream_t *s, const char *driver))
     532               0 : UNSUPPORTED(int sa_stream_start_thread(sa_stream_t *s, sa_event_callback_t callback))
     533               0 : UNSUPPORTED(int sa_stream_stop_thread(sa_stream_t *s))
     534               0 : UNSUPPORTED(int sa_stream_change_device(sa_stream_t *s, const char *device_name))
     535               0 : UNSUPPORTED(int sa_stream_change_read_volume(sa_stream_t *s, const int32_t vol[], unsigned int n))
     536               0 : UNSUPPORTED(int sa_stream_change_write_volume(sa_stream_t *s, const int32_t vol[], unsigned int n))
     537               0 : UNSUPPORTED(int sa_stream_change_rate(sa_stream_t *s, unsigned int rate))
     538               0 : UNSUPPORTED(int sa_stream_change_meta_data(sa_stream_t *s, const char *name, const void *data, size_t size))
     539               0 : UNSUPPORTED(int sa_stream_change_user_data(sa_stream_t *s, const void *value))
     540               0 : UNSUPPORTED(int sa_stream_set_adjust_rate(sa_stream_t *s, sa_adjust_t direction))
     541               0 : UNSUPPORTED(int sa_stream_set_adjust_nchannels(sa_stream_t *s, sa_adjust_t direction))
     542               0 : UNSUPPORTED(int sa_stream_set_adjust_pcm_format(sa_stream_t *s, sa_adjust_t direction))
     543               0 : UNSUPPORTED(int sa_stream_set_adjust_watermarks(sa_stream_t *s, sa_adjust_t direction))
     544               0 : UNSUPPORTED(int sa_stream_get_mode(sa_stream_t *s, sa_mode_t *access_mode))
     545               0 : UNSUPPORTED(int sa_stream_get_codec(sa_stream_t *s, char *codec, size_t *size))
     546               0 : UNSUPPORTED(int sa_stream_get_pcm_format(sa_stream_t *s, sa_pcm_format_t *format))
     547               0 : UNSUPPORTED(int sa_stream_get_rate(sa_stream_t *s, unsigned int *rate))
     548               0 : UNSUPPORTED(int sa_stream_get_nchannels(sa_stream_t *s, int *nchannels))
     549               0 : UNSUPPORTED(int sa_stream_get_user_data(sa_stream_t *s, void **value))
     550               0 : UNSUPPORTED(int sa_stream_get_write_lower_watermark(sa_stream_t *s, size_t *size))
     551               0 : UNSUPPORTED(int sa_stream_get_read_lower_watermark(sa_stream_t *s, size_t *size))
     552               0 : UNSUPPORTED(int sa_stream_get_write_upper_watermark(sa_stream_t *s, size_t *size))
     553               0 : UNSUPPORTED(int sa_stream_get_read_upper_watermark(sa_stream_t *s, size_t *size))
     554               0 : UNSUPPORTED(int sa_stream_get_channel_map(sa_stream_t *s, sa_channel_t map[], unsigned int *n))
     555               0 : UNSUPPORTED(int sa_stream_get_xrun_mode(sa_stream_t *s, sa_xrun_mode_t *mode))
     556               0 : UNSUPPORTED(int sa_stream_get_non_interleaved(sa_stream_t *s, int *enabled))
     557               0 : UNSUPPORTED(int sa_stream_get_dynamic_rate(sa_stream_t *s, int *enabled))
     558               0 : UNSUPPORTED(int sa_stream_get_driver(sa_stream_t *s, char *driver_name, size_t *size))
     559               0 : UNSUPPORTED(int sa_stream_get_device(sa_stream_t *s, char *device_name, size_t *size))
     560               0 : UNSUPPORTED(int sa_stream_get_read_volume(sa_stream_t *s, int32_t vol[], unsigned int *n))
     561               0 : UNSUPPORTED(int sa_stream_get_write_volume(sa_stream_t *s, int32_t vol[], unsigned int *n))
     562               0 : UNSUPPORTED(int sa_stream_get_meta_data(sa_stream_t *s, const char *name, void*data, size_t *size))
     563               0 : UNSUPPORTED(int sa_stream_get_adjust_rate(sa_stream_t *s, sa_adjust_t *direction))
     564               0 : UNSUPPORTED(int sa_stream_get_adjust_nchannels(sa_stream_t *s, sa_adjust_t *direction))
     565               0 : UNSUPPORTED(int sa_stream_get_adjust_pcm_format(sa_stream_t *s, sa_adjust_t *direction))
     566               0 : UNSUPPORTED(int sa_stream_get_adjust_watermarks(sa_stream_t *s, sa_adjust_t *direction))
     567               0 : UNSUPPORTED(int sa_stream_get_state(sa_stream_t *s, sa_state_t *state))
     568               0 : UNSUPPORTED(int sa_stream_get_event_error(sa_stream_t *s, sa_error_t *error))
     569               0 : UNSUPPORTED(int sa_stream_get_event_notify(sa_stream_t *s, sa_notify_t *notify))
     570               0 : UNSUPPORTED(int sa_stream_read(sa_stream_t *s, void *data, size_t nbytes))
     571               0 : UNSUPPORTED(int sa_stream_read_ni(sa_stream_t *s, unsigned int channel, void *data, size_t nbytes))
     572               0 : UNSUPPORTED(int sa_stream_write_ni(sa_stream_t *s, unsigned int channel, const void *data, size_t nbytes))
     573               0 : UNSUPPORTED(int sa_stream_pwrite(sa_stream_t *s, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence))
     574               0 : UNSUPPORTED(int sa_stream_pwrite_ni(sa_stream_t *s, unsigned int channel, const void *data, size_t nbytes, int64_t offset, sa_seek_t whence))
     575               0 : UNSUPPORTED(int sa_stream_get_read_size(sa_stream_t *s, size_t *size))
     576                 : 
     577               0 : const char *sa_strerror(int code) { return NULL; }
     578                 : 

Generated by: LCOV version 1.7