reactos/base/applications/tsclient/rdesktop/rdpsnd_sun.c

   1 /* -*- c-basic-offset: 8 -*-
   2    rdesktop: A Remote Desktop Protocol client.
   3    Sound Channel Process Functions - Sun
   4    Copyright (C) Matthew Chapman 2003
   5    Copyright (C) GuoJunBo guojunbo@ict.ac.cn 2003
   6    Copyright (C) Michael Gernoth mike@zerfleddert.de 2003
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "rdesktop.h"
  24 #include <unistd.h>
  25 #include <fcntl.h>
  26 #include <errno.h>
  27 #include <sys/ioctl.h>
  28 #include <sys/audioio.h>
  29
  30 #if (defined(sun) && (defined(__svr4__) || defined(__SVR4)))
  31 #include <stropts.h>
  32 #endif
  33
  34 #define MAX_QUEUE       10
  35
  36 int This->dsp_;
  37 BOOL This->dsp_bu = False;
  38 static BOOL g_reopened;
  39 static BOOL g_swapaudio;
  40 static short g_samplewidth;
  41
  42 static struct audio_packet
  43 {
  44         struct stream s;
  45         uint16 tick;
  46         uint8 index;
  47 } packet_queue[MAX_QUEUE];
  48 static unsigned int queue_hi, queue_lo;
  49
  50 BOOL
  51 wave_out_open(void)
  52 {
  53         char *dsp_dev = getenv("AUDIODEV");
  54
  55         if (dsp_dev == NULL)
  56         {
  57                 dsp_dev = xstrdup("/dev/audio");
  58         }
  59
  60         if ((This->dsp_ = open(dsp_dev, O_WRONLY | O_NONBLOCK)) == -1)
  61         {
  62                 perror(dsp_dev);
  63                 return False;
  64         }
  65
  66         /* Non-blocking so that user interface is responsive */
  67         fcntl(This->dsp_, F_SETFL, fcntl(This->dsp_, F_GETFL) | O_NONBLOCK);
  68
  69         queue_lo = queue_hi = 0;
  70         g_reopened = True;
  71
  72         return True;
  73 }
  74
  75 void
  76 wave_out_close(void)
  77 {
  78         /* Ack all remaining packets */
  79         while (queue_lo != queue_hi)
  80         {
  81                 rdpsnd_send_completion(packet_queue[queue_lo].tick, packet_queue[queue_lo].index);
  82                 free(packet_queue[queue_lo].s.data);
  83                 queue_lo = (queue_lo + 1) % MAX_QUEUE;
  84         }
  85
  86 #if defined I_FLUSH && defined FLUSHW
  87         /* Flush the audiobuffer */
  88         ioctl(This->dsp_, I_FLUSH, FLUSHW);
  89 #endif
  90 #if defined AUDIO_FLUSH
  91         ioctl(This->dsp_, AUDIO_FLUSH, NULL);
  92 #endif
  93         close(This->dsp_);
  94 }
  95
  96 BOOL
  97 wave_out_format_supported(WAVEFORMATEX * pwfx)
  98 {
  99         if (pwfx->wFormatTag != WAVE_FORMAT_PCM)
 100                 return False;
 101         if ((pwfx->nChannels != 1) && (pwfx->nChannels != 2))
 102                 return False;
 103         if ((pwfx->wBitsPerSample != 8) && (pwfx->wBitsPerSample != 16))
 104                 return False;
 105
 106         return True;
 107 }
 108
 109 BOOL
 110 wave_out_set_format(WAVEFORMATEX * pwfx)
 111 {
 112         audio_info_t info;
 113
 114         ioctl(This->dsp_, AUDIO_DRAIN, 0);
 115         g_swapaudio = False;
 116         AUDIO_INITINFO(&info);
 117
 118
 119         if (pwfx->wBitsPerSample == 8)
 120         {
 121                 info.play.encoding = AUDIO_ENCODING_LINEAR8;
 122         }
 123         else if (pwfx->wBitsPerSample == 16)
 124         {
 125                 info.play.encoding = AUDIO_ENCODING_LINEAR;
 126                 /* Do we need to swap the 16bit values? (Are we BigEndian) */
 127 #ifdef B_ENDIAN
 128                 g_swapaudio = 1;
 129 #else
 130                 g_swapaudio = 0;
 131 #endif
 132         }
 133
 134         g_samplewidth = pwfx->wBitsPerSample / 8;
 135
 136         if (pwfx->nChannels == 1)
 137         {
 138                 info.play.channels = 1;
 139         }
 140         else if (pwfx->nChannels == 2)
 141         {
 142                 info.play.channels = 2;
 143                 g_samplewidth *= 2;
 144         }
 145
 146         info.play.sample_rate = pwfx->nSamplesPerSec;
 147         info.play.precision = pwfx->wBitsPerSample;
 148         info.play.samples = 0;
 149         info.play.eof = 0;
 150         info.play.error = 0;
 151         g_reopened = True;
 152
 153         if (ioctl(This->dsp_, AUDIO_SETINFO, &info) == -1)
 154         {
 155                 perror("AUDIO_SETINFO");
 156                 close(This->dsp_);
 157                 return False;
 158         }
 159
 160         return True;
 161 }
 162
 163 void
 164 wave_out_volume(uint16 left, uint16 right)
 165 {
 166         audio_info_t info;
 167         uint balance;
 168         uint volume;
 169
 170         AUDIO_INITINFO(&info);
 171
 172         volume = (left > right) ? left : right;
 173
 174         if (volume / AUDIO_MID_BALANCE != 0)
 175         {
 176                 balance =
 177                         AUDIO_MID_BALANCE - (left / (volume / AUDIO_MID_BALANCE)) +
 178                         (right / (volume / AUDIO_MID_BALANCE));
 179         }
 180         else
 181         {
 182                 balance = AUDIO_MID_BALANCE;
 183         }
 184
 185         info.play.gain = volume / (65536 / AUDIO_MAX_GAIN);
 186         info.play.balance = balance;
 187
 188         if (ioctl(This->dsp_, AUDIO_SETINFO, &info) == -1)
 189         {
 190                 perror("AUDIO_SETINFO");
 191                 return;
 192         }
 193 }
 194
 195 void
 196 wave_out_write(STREAM s, uint16 tick, uint8 index)
 197 {
 198         struct audio_packet *packet = &packet_queue[queue_hi];
 199         unsigned int next_hi = (queue_hi + 1) % MAX_QUEUE;
 200
 201         if (next_hi == queue_lo)
 202         {
 203                 error("No space to queue audio packet\n");
 204                 return;
 205         }
 206
 207         queue_hi = next_hi;
 208
 209         packet->s = *s;
 210         packet->tick = tick;
 211         packet->index = index;
 212         packet->s.p += 4;
 213
 214         /* we steal the data buffer from s, give it a new one */
 215         s->data = malloc(s->size);
 216
 217         if (!This->dsp_bu)
 218                 wave_out_play();
 219 }
 220
 221 void
 222 wave_out_play(void)
 223 {
 224         struct audio_packet *packet;
 225         audio_info_t info;
 226         ssize_t len;
 227         unsigned int i;
 228         uint8 swap;
 229         STREAM out;
 230         static BOOL swapped = False;
 231         static BOOL sentcompletion = True;
 232         static uint32 samplecnt = 0;
 233         static uint32 numsamples;
 234
 235         while (1)
 236         {
 237                 if (g_reopened)
 238                 {
 239                         /* Device was just (re)openend */
 240                         samplecnt = 0;
 241                         swapped = False;
 242                         sentcompletion = True;
 243                         g_reopened = False;
 244                 }
 245
 246                 if (queue_lo == queue_hi)
 247                 {
 248                         This->dsp_bu = 0;
 249                         return;
 250                 }
 251
 252                 packet = &packet_queue[queue_lo];
 253                 out = &packet->s;
 254
 255                 /* Swap the current packet, but only once */
 256                 if (g_swapaudio && !swapped)
 257                 {
 258                         for (i = 0; i < out->end - out->p; i += 2)
 259                         {
 260                                 swap = *(out->p + i);
 261                                 *(out->p + i) = *(out->p + i + 1);
 262                                 *(out->p + i + 1) = swap;
 263                         }
 264                         swapped = True;
 265                 }
 266
 267                 if (sentcompletion)
 268                 {
 269                         sentcompletion = False;
 270                         numsamples = (out->end - out->p) / g_samplewidth;
 271                 }
 272
 273                 len = 0;
 274
 275                 if (out->end != out->p)
 276                 {
 277                         len = write(This->dsp_, out->p, out->end - out->p);
 278                         if (len == -1)
 279                         {
 280                                 if (errno != EWOULDBLOCK)
 281                                         perror("write audio");
 282                                 This->dsp_bu = 1;
 283                                 return;
 284                         }
 285                 }
 286
 287                 out->p += len;
 288                 if (out->p == out->end)
 289                 {
 290                         if (ioctl(This->dsp_, AUDIO_GETINFO, &info) == -1)
 291                         {
 292                                 perror("AUDIO_GETINFO");
 293                                 return;
 294                         }
 295
 296                         /* Ack the packet, if we have played at least 70% */
 297                         if (info.play.samples >= samplecnt + ((numsamples * 7) / 10))
 298                         {
 299                                 samplecnt += numsamples;
 300                                 rdpsnd_send_completion(packet->tick, packet->index);
 301                                 free(out->data);
 302                                 queue_lo = (queue_lo + 1) % MAX_QUEUE;
 303                                 swapped = False;
 304                                 sentcompletion = True;
 305                         }
 306                         else
 307                         {
 308                                 This->dsp_bu = 1;
 309                                 return;
 310                         }
 311                 }
 312         }
 313 }