/[rdesktop]/jpeg/rdesktop/trunk/rdpsnd_oss.c

This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!

Diff of /jpeg/rdesktop/trunk/rdpsnd_oss.c

Parent Directory | Revision Log | View Patch Patch

-revision 499 by astrand,
Wed Oct 15 14:01:32 2003 UTC
+revision 1481 by astrand,
Thu Oct  2 18:21:58 2008 UTC
 Line 1
- /*
+ /* -*- c-basic-offset: 8 -*-
     rdesktop: A Remote Desktop Protocol client.
     Sound Channel Process Functions - Open Sound System
-    Copyright (C) Matthew Chapman 2003
+    Copyright (C) Matthew Chapman 2003-2008
     Copyright (C) GuoJunBo guojunbo@ict.ac.cn 2003
+    Copyright 2006-2008 Pierre Ossman <ossman@cendio.se> for Cendio AB
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
-Line 19
+Line 20
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
+ /*
+    This is a workaround for Esound bug 312665.
+    FIXME: Remove this when Esound is fixed.
+ */
+ #ifdef _FILE_OFFSET_BITS
+ #undef _FILE_OFFSET_BITS
+ #endif
+ #include <assert.h>
  #include "rdesktop.h"
+ #include "rdpsnd.h"
+ #include "rdpsnd_dsp.h"
  #include <unistd.h>
  #include <fcntl.h>
  #include <errno.h>
+ #include <unistd.h>
+ #include <sys/time.h>
  #include <sys/ioctl.h>
  #include <sys/soundcard.h>
+ #include <sys/types.h>
+ #include <sys/stat.h>
+ #define DEFAULTDEVICE   "/dev/dsp"
+ #define MAX_LEN         512
- #define MAX_QUEUE       10
+ static int dsp_fd = -1;
+ static int dsp_mode;
- int g_dsp_fd;
+ static RD_BOOL dsp_configured;
- BOOL g_dsp_busy;
+ static RD_BOOL dsp_broken;
+ static int stereo;
+ static int format;
+ static uint32 snd_rate;
+ static short samplewidth;
+ static char *dsp_dev;
+ static RD_BOOL in_esddsp;
+ /* This is a just a forward declaration */
+ static struct audio_driver oss_driver;
+ static void oss_play(void);
+ static void oss_record(void);
+ static RD_BOOL oss_set_format(RD_WAVEFORMATEX * pwfx);
- static struct audio_packet
+ static void
+ oss_add_fds(int *n, fd_set * rfds, fd_set * wfds, struct timeval *tv)
  {
-         struct stream s;
+         if (dsp_fd == -1)
-         uint16 tick;
+                 return;
-         uint8 index;
- } packet_queue[MAX_QUEUE];
+         if ((dsp_mode == O_WRONLY || dsp_mode == O_RDWR) && !rdpsnd_queue_empty())
- static unsigned int queue_hi, queue_lo;
+                 FD_SET(dsp_fd, wfds);
+         if (dsp_mode == O_RDONLY || dsp_mode == O_RDWR)
+                 FD_SET(dsp_fd, rfds);
+         if (dsp_fd > *n)
+                 *n = dsp_fd;
+ }
+ static void
+ oss_check_fds(fd_set * rfds, fd_set * wfds)
+ {
+         if (FD_ISSET(dsp_fd, wfds))
+                 oss_play();
+         if (FD_ISSET(dsp_fd, rfds))
+                 oss_record();
+ }
+ static RD_BOOL
+ detect_esddsp(void)
+ {
+         struct stat s;
+         char *preload;
+         if (fstat(dsp_fd, &s) == -1)
+                 return False;
- BOOL
+         if (S_ISCHR(s.st_mode) || S_ISBLK(s.st_mode))
- wave_out_open(void)
+                 return False;
+         preload = getenv("LD_PRELOAD");
+         if (preload == NULL)
+                 return False;
+         if (strstr(preload, "esddsp") == NULL)
+                 return False;
+         return True;
+ }
+ static void
+ oss_restore_format()
  {
-         char *dsp_dev = "/dev/dsp";
+         RD_WAVEFORMATEX wfx;
+         memset(&wfx, 0, sizeof(RD_WAVEFORMATEX));
+         switch (format)
+         {
+                 case AFMT_U8:
+                         wfx.wBitsPerSample = 8;
+                         break;
+                 case AFMT_S16_LE:
+                         wfx.wBitsPerSample = 16;
+                         break;
+                 default:
+                         wfx.wBitsPerSample = 0;
+         }
+         wfx.nChannels = stereo ? 2 : 1;
+         wfx.nSamplesPerSec = snd_rate;
+         oss_set_format(&wfx);
+ }
-         if ((g_dsp_fd = open(dsp_dev, O_WRONLY | O_NONBLOCK)) == -1)
+ static RD_BOOL
+ oss_open(int wanted)
+ {
+         if (dsp_fd != -1)
+         {
+                 if (wanted == dsp_mode)
+                 {
+                         /* should probably not happen */
+                         return True;
+                 }
+                 else
+                 {
+                         /* device open but not our mode. Before
+                            reopening O_RDWR, verify that the device is
+                            duplex capable */
+                         int caps;
+                         ioctl(dsp_fd, SNDCTL_DSP_SETDUPLEX, 0);
+                         if ((ioctl(dsp_fd, SNDCTL_DSP_GETCAPS, &caps) < 0)
+                             || !(caps & DSP_CAP_DUPLEX))
+                         {
+                                 warning("This device is not capable of full duplex operation.\n");
+                                 return False;
+                         }
+                         close(dsp_fd);
+                         dsp_mode = O_RDWR;
+                 }
+         }
+         else
+         {
+                 dsp_mode = wanted;
+         }
+         dsp_configured = False;
+         dsp_broken = False;
+         dsp_fd = open(dsp_dev, dsp_mode | O_NONBLOCK);
+         if (dsp_fd == -1)
          {
                  perror(dsp_dev);
                  return False;
          }
-         /* Non-blocking so that user interface is responsive */
+         in_esddsp = detect_esddsp();
-         fcntl(g_dsp_fd, F_SETFL, fcntl(g_dsp_fd, F_GETFL) | O_NONBLOCK);
          return True;
  }
- void
+ static void
- wave_out_close(void)
+ oss_close(void)
+ {
+         close(dsp_fd);
+         dsp_fd = -1;
+ }
+ static RD_BOOL
+ oss_open_out(void)
  {
-         close(g_dsp_fd);
+         if (!oss_open(O_WRONLY))
+                 return False;
+         return True;
+ }
+ static void
+ oss_close_out(void)
+ {
+         oss_close();
+         if (dsp_mode == O_RDWR)
+         {
+                 if (oss_open(O_RDONLY))
+                         oss_restore_format();
+         }
+         /* Ack all remaining packets */
+         while (!rdpsnd_queue_empty())
+                 rdpsnd_queue_next(0);
+ }
+ static RD_BOOL
+ oss_open_in(void)
+ {
+         if (!oss_open(O_RDONLY))
+                 return False;
+         return True;
+ }
+ static void
+ oss_close_in(void)
+ {
+         oss_close();
+         if (dsp_mode == O_RDWR)
+         {
+                 if (oss_open(O_WRONLY))
+                         oss_restore_format();
+         }
  }
- BOOL
+ static RD_BOOL
- wave_out_format_supported(WAVEFORMATEX * pwfx)
+ oss_format_supported(RD_WAVEFORMATEX * pwfx)
  {
          if (pwfx->wFormatTag != WAVE_FORMAT_PCM)
                  return False;
-Line 74 
 wave_out_format_supported(WAVEFORMATEX *
+Line 246 
 wave_out_format_supported(WAVEFORMATEX *
          return True;
  }
- BOOL
+ static RD_BOOL
- wave_out_set_format(WAVEFORMATEX * pwfx)
+ oss_set_format(RD_WAVEFORMATEX * pwfx)
  {
-         int speed, channels, format;
+         int fragments;
+         static RD_BOOL driver_broken = False;
-         ioctl(g_dsp_fd, SNDCTL_DSP_RESET, NULL);
+         assert(dsp_fd != -1);
-         ioctl(g_dsp_fd, SNDCTL_DSP_SYNC, NULL);
+         if (dsp_configured)
+         {
+                 if ((pwfx->wBitsPerSample == 8) && (format != AFMT_U8))
+                         return False;
+                 if ((pwfx->wBitsPerSample == 16) && (format != AFMT_S16_LE))
+                         return False;
+                 if ((pwfx->nChannels == 2) != !!stereo)
+                         return False;
+                 if (pwfx->nSamplesPerSec != snd_rate)
+                         return False;
+                 return True;
+         }
+         ioctl(dsp_fd, SNDCTL_DSP_RESET, NULL);
+         ioctl(dsp_fd, SNDCTL_DSP_SYNC, NULL);
          if (pwfx->wBitsPerSample == 8)
                  format = AFMT_U8;
          else if (pwfx->wBitsPerSample == 16)
                  format = AFMT_S16_LE;
-         if (ioctl(g_dsp_fd, SNDCTL_DSP_SETFMT, &format) == -1)
+         samplewidth = pwfx->wBitsPerSample / 8;
+         if (ioctl(dsp_fd, SNDCTL_DSP_SETFMT, &format) == -1)
          {
                  perror("SNDCTL_DSP_SETFMT");
-                 close(g_dsp_fd);
+                 oss_close();
                  return False;
          }
-         channels = pwfx->nChannels;
+         if (pwfx->nChannels == 2)
-         if (ioctl(g_dsp_fd, SNDCTL_DSP_CHANNELS, &channels) == -1)
+         {
+                 stereo = 1;
+                 samplewidth *= 2;
+         }
+         else
+         {
+                 stereo = 0;
+         }
+         if (ioctl(dsp_fd, SNDCTL_DSP_STEREO, &stereo) == -1)
          {
                  perror("SNDCTL_DSP_CHANNELS");
-                 close(g_dsp_fd);
+                 oss_close();
                  return False;
          }
-         speed = pwfx->nSamplesPerSec;
+         oss_driver.need_resampling = 0;
-         if (ioctl(g_dsp_fd, SNDCTL_DSP_SPEED, &speed) == -1)
+         snd_rate = pwfx->nSamplesPerSec;
+         if (ioctl(dsp_fd, SNDCTL_DSP_SPEED, &snd_rate) == -1)
          {
-                 perror("SNDCTL_DSP_SPEED");
+                 uint32 rates[] = { 44100, 48000, 0 };
-                 close(g_dsp_fd);
+                 uint32 *prates = rates;
-                 return False;
+                 while (*prates != 0)
+                 {
+                         if ((pwfx->nSamplesPerSec != *prates)
+                             && (ioctl(dsp_fd, SNDCTL_DSP_SPEED, prates) != -1))
+                         {
+                                 oss_driver.need_resampling = 1;
+                                 snd_rate = *prates;
+                                 if (rdpsnd_dsp_resample_set
+                                     (snd_rate, pwfx->wBitsPerSample, pwfx->nChannels) == False)
+                                 {
+                                         error("rdpsnd_dsp_resample_set failed");
+                                         oss_close();
+                                         return False;
+                                 }
+                                 break;
+                         }
+                         prates++;
+                 }
+                 if (*prates == 0)
+                 {
+                         perror("SNDCTL_DSP_SPEED");
+                         oss_close();
+                         return False;
+                 }
+         }
+         /* try to get 12 fragments of 2^12 bytes size */
+         fragments = (12 << 16) + 12;
+         ioctl(dsp_fd, SNDCTL_DSP_SETFRAGMENT, &fragments);
+         if (!driver_broken)
+         {
+                 audio_buf_info info;
+                 memset(&info, 0, sizeof(info));
+                 if (ioctl(dsp_fd, SNDCTL_DSP_GETOSPACE, &info) == -1)
+                 {
+                         perror("SNDCTL_DSP_GETOSPACE");
+                         oss_close();
+                         return False;
+                 }
+                 if (info.fragments == 0 || info.fragstotal == 0 || info.fragsize == 0)
+                 {
+                         fprintf(stderr,
+                                 "Broken OSS-driver detected: fragments: %d, fragstotal: %d, fragsize: %d\n",
+                                 info.fragments, info.fragstotal, info.fragsize);
+                         driver_broken = True;
+                 }
          }
+         dsp_configured = True;
          return True;
  }
- void
+ static void
- wave_out_volume(uint16 left, uint16 right)
+ oss_volume(uint16 left, uint16 right)
  {
          uint32 volume;
          volume = left / (65536 / 100);
          volume |= right / (65536 / 100) << 8;
-         if (ioctl(g_dsp_fd, MIXER_WRITE(SOUND_MIXER_PCM), &volume) == -1)
+         if (ioctl(dsp_fd, MIXER_WRITE(SOUND_MIXER_PCM), &volume) == -1)
          {
-                 perror("MIXER_WRITE(SOUND_MIXER_PCM)");
+                 warning("hardware volume control unavailable, falling back to software volume control!\n");
+                 oss_driver.wave_out_volume = rdpsnd_dsp_softvol_set;
+                 rdpsnd_dsp_softvol_set(left, right);
                  return;
          }
  }
- void
+ static void
- wave_out_write(STREAM s, uint16 tick, uint8 index)
+ oss_play(void)
  {
-         struct audio_packet *packet = &packet_queue[queue_hi];
+         struct audio_packet *packet;
-         unsigned int next_hi = (queue_hi + 1) % MAX_QUEUE;
+         ssize_t len;
+         STREAM out;
+         assert(dsp_fd != -1);
+         /* We shouldn't be called if the queue is empty, but still */
+         if (rdpsnd_queue_empty())
+                 return;
-         if (next_hi == queue_lo)
+         packet = rdpsnd_queue_current_packet();
+         out = &packet->s;
+         len = out->end - out->p;
+         len = write(dsp_fd, out->p, (len > MAX_LEN) ? MAX_LEN : len);
+         if (len == -1)
          {
-                 error("No space to queue audio packet\n");
+                 if (errno != EWOULDBLOCK)
+                 {
+                         if (!dsp_broken)
+                                 perror("RDPSND: write()");
+                         dsp_broken = True;
+                         rdpsnd_queue_next(0);
+                 }
                  return;
          }
-         queue_hi = next_hi;
+         dsp_broken = False;
-         packet->s = *s;
+         out->p += len;
-         packet->tick = tick;
-         packet->index = index;
-         packet->s.p += 4;
-         /* we steal the data buffer from s, give it a new one */
+         if (out->p == out->end)
-         s->data = malloc(s->size);
+         {
+                 int delay_bytes;
+                 unsigned long delay_us;
+                 audio_buf_info info;
+                 if (in_esddsp)
+                 {
+                         /* EsounD has no way of querying buffer status, so we have to
+                          * go with a fixed size. */
+                         delay_bytes = out->size;
+                 }
+                 else
+                 {
+ #ifdef SNDCTL_DSP_GETODELAY
+                         delay_bytes = 0;
+                         if (ioctl(dsp_fd, SNDCTL_DSP_GETODELAY, &delay_bytes) == -1)
+                                 delay_bytes = -1;
+ #else
+                         delay_bytes = -1;
+ #endif
+                         if (delay_bytes == -1)
+                         {
+                                 if (ioctl(dsp_fd, SNDCTL_DSP_GETOSPACE, &info) != -1)
+                                         delay_bytes = info.fragstotal * info.fragsize - info.bytes;
+                                 else
+                                         delay_bytes = out->size;
+                         }
+                 }
-         if (!g_dsp_busy)
+                 delay_us = delay_bytes * (1000000 / (samplewidth * snd_rate));
-                 wave_out_play();
+                 rdpsnd_queue_next(delay_us);
+         }
  }
- void
+ static void
- wave_out_play(void)
+ oss_record(void)
  {
-         struct audio_packet *packet;
+         char buffer[32768];
-         ssize_t len;
+         int len;
-         STREAM out;
-         while (1)
+         assert(dsp_fd != -1);
+         len = read(dsp_fd, buffer, sizeof(buffer));
+         if (len == -1)
          {
-                 if (queue_lo == queue_hi)
+                 if (errno != EWOULDBLOCK)
                  {
-                         g_dsp_busy = 0;
+                         if (!dsp_broken)
-                         return;
+                                 perror("RDPSND: read()");
+                         dsp_broken = True;
+                         rdpsnd_queue_next(0);
                  }
+                 return;
+         }
-                 packet = &packet_queue[queue_lo];
+         dsp_broken = False;
-                 out = &packet->s;
-                 len = write(g_dsp_fd, out->p, out->end - out->p);
+         rdpsnd_record(buffer, len);
-                 if (len == -1)
+ }
-                 {
-                         if (errno != EWOULDBLOCK)
+ struct audio_driver *
-                                 perror("write audio");
+ oss_register(char *options)
-                         g_dsp_busy = 1;
+ {
-                         return;
+         memset(&oss_driver, 0, sizeof(oss_driver));
-                 }
+         oss_driver.name = "oss";
+         oss_driver.description =
+                 "OSS output driver, default device: " DEFAULTDEVICE " or $AUDIODEV";
+         oss_driver.add_fds = oss_add_fds;
+         oss_driver.check_fds = oss_check_fds;
+         oss_driver.wave_out_open = oss_open_out;
+         oss_driver.wave_out_close = oss_close_out;
+         oss_driver.wave_out_format_supported = oss_format_supported;
+         oss_driver.wave_out_set_format = oss_set_format;
+         oss_driver.wave_out_volume = oss_volume;
+         oss_driver.wave_in_open = oss_open_in;
+         oss_driver.wave_in_close = oss_close_in;
+         oss_driver.wave_in_format_supported = oss_format_supported;
+         oss_driver.wave_in_set_format = oss_set_format;
+         oss_driver.wave_in_volume = NULL;       /* FIXME */
+         oss_driver.need_byteswap_on_be = 0;
+         oss_driver.need_resampling = 0;
+         if (options)
+         {
+                 dsp_dev = xstrdup(options);
+         }
+         else
+         {
+                 dsp_dev = getenv("AUDIODEV");
-                 out->p += len;
+                 if (dsp_dev == NULL)
-                 if (out->p == out->end)
                  {
-                         rdpsnd_send_completion(packet->tick, packet->index);
+                         dsp_dev = DEFAULTDEVICE;
-                         free(out->data);
-                         queue_lo = (queue_lo + 1) % MAX_QUEUE;
                  }
          }
+         return &oss_driver;
  }

 Legend:



Removed from v.499
 


changed lines


 
Added in v.1481
 Legend:



Removed from v.499
 


changed lines


 
Added in v.1481
-Removed from v.499
+Added in v.1481

	ViewVC Help
Powered by ViewVC 1.1.26