/[rdesktop]/jpeg/rdesktop/trunk/rdpsnd_libao.c
This is repository of my old source code which isn't updated any more. Go to git.rot13.org for current projects!
ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 963 by astrand, Wed Aug 3 10:56:16 2005 UTC revision 1373 by stargo, Mon Jan 8 12:38:34 2007 UTC
# Line 1  Line 1 
1  /* -*- c-basic-offset: 8 -*-  /* -*- c-basic-offset: 8 -*-
2     rdesktop: A Remote Desktop Protocol client.     rdesktop: A Remote Desktop Protocol client.
3     Sound Channel Process Functions - libao-driver     Sound Channel Process Functions - libao-driver
4     Copyright (C) Matthew Chapman 2003     Copyright (C) Matthew Chapman 2003-2007
5     Copyright (C) GuoJunBo guojunbo@ict.ac.cn 2003     Copyright (C) GuoJunBo guojunbo@ict.ac.cn 2003
6     Copyright (C) Michael Gernoth mike@zerfleddert.de 2005     Copyright (C) Michael Gernoth mike@zerfleddert.de 2005-2007
7    
8     This program is free software; you can redistribute it and/or modify     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     it under the terms of the GNU General Public License as published by
# Line 21  Line 21 
21  */  */
22    
23  #include "rdesktop.h"  #include "rdesktop.h"
24    #include "rdpsnd.h"
25    #include "rdpsnd_dsp.h"
26  #include <unistd.h>  #include <unistd.h>
27  #include <fcntl.h>  #include <fcntl.h>
28  #include <errno.h>  #include <errno.h>
29  #include <ao/ao.h>  #include <ao/ao.h>
30  #include <sys/time.h>  #include <sys/time.h>
31    
32  #define MAX_QUEUE       10  #define WAVEOUTLEN      16
 #define WAVEOUTBUF      64  
33    
34  int g_dsp_fd;  static ao_device *o_device = NULL;
35  ao_device *o_device = NULL;  static int default_driver;
36  int default_driver;  static RD_BOOL reopened;
37  int g_samplerate;  static char *libao_device = NULL;
 int g_channels;  
 BOOL g_dsp_busy = False;  
 static BOOL g_reopened;  
 static short g_samplewidth;  
38    
39  static struct audio_packet  void libao_play(void);
40    
41    void
42    libao_add_fds(int *n, fd_set * rfds, fd_set * wfds, struct timeval *tv)
43    {
44            /* We need to be called rather often... */
45            FD_SET(0, wfds);
46    }
47    
48    void
49    libao_check_fds(fd_set * rfds, fd_set * wfds)
50  {  {
51          struct stream s;          if (o_device == NULL)
52          uint16 tick;                  return;
53          uint8 index;  
54  } packet_queue[MAX_QUEUE];          if (!rdpsnd_queue_empty())
55  static unsigned int queue_hi, queue_lo;                  libao_play();
56    }
57    
58  BOOL  RD_BOOL
59  wave_out_open(void)  libao_open(void)
60  {  {
61          ao_sample_format format;          ao_sample_format format;
62    
63          ao_initialize();          ao_initialize();
64          default_driver = ao_default_driver_id();  
65            if (libao_device)
66            {
67                    default_driver = ao_driver_id(libao_device);
68            }
69            else
70            {
71                    default_driver = ao_default_driver_id();
72            }
73    
74          format.bits = 16;          format.bits = 16;
75          format.channels = 2;          format.channels = 2;
         g_channels = 2;  
76          format.rate = 44100;          format.rate = 44100;
77          g_samplerate = 44100;          format.byte_format = AO_FMT_NATIVE;
78          format.byte_format = AO_FMT_LITTLE;  
79    
80          o_device = ao_open_live(default_driver, &format, NULL);          o_device = ao_open_live(default_driver, &format, NULL);
81          if (o_device == NULL)          if (o_device == NULL)
# Line 68  wave_out_open(void) Line 83  wave_out_open(void)
83                  return False;                  return False;
84          }          }
85    
86          g_dsp_fd = 0;          reopened = True;
         queue_lo = queue_hi = 0;  
   
         g_reopened = True;  
87    
88          return True;          return True;
89  }  }
90    
91  void  void
92  wave_out_close(void)  libao_close(void)
93  {  {
94          /* Ack all remaining packets */          /* Ack all remaining packets */
95          while (queue_lo != queue_hi)          while (!rdpsnd_queue_empty())
96          {          {
97                  rdpsnd_send_completion(packet_queue[queue_lo].tick, packet_queue[queue_lo].index);                  rdpsnd_queue_next(0);
                 free(packet_queue[queue_lo].s.data);  
                 queue_lo = (queue_lo + 1) % MAX_QUEUE;  
98          }          }
99    
100          if (o_device != NULL)          if (o_device != NULL)
101                  ao_close(o_device);                  ao_close(o_device);
102    
103          ao_shutdown();          o_device = NULL;
 }  
   
 BOOL  
 wave_out_format_supported(WAVEFORMATEX * pwfx)  
 {  
         if (pwfx->wFormatTag != WAVE_FORMAT_PCM)  
                 return False;  
         if ((pwfx->nChannels != 1) && (pwfx->nChannels != 2))  
                 return False;  
         if ((pwfx->wBitsPerSample != 8) && (pwfx->wBitsPerSample != 16))  
                 return False;  
         /* The only common denominator between libao output drivers is a sample-rate of  
            44100, we need to upsample 22050 to it */  
         if ((pwfx->nSamplesPerSec != 44100) && (pwfx->nSamplesPerSec != 22050))  
                 return False;  
104    
105          return True;          ao_shutdown();
106  }  }
107    
108  BOOL  RD_BOOL
109  wave_out_set_format(WAVEFORMATEX * pwfx)  libao_set_format(RD_WAVEFORMATEX * pwfx)
110  {  {
111          ao_sample_format format;          ao_sample_format format;
112    
113          format.bits = pwfx->wBitsPerSample;          format.bits = pwfx->wBitsPerSample;
114          format.channels = pwfx->nChannels;          format.channels = pwfx->nChannels;
         g_channels = pwfx->nChannels;  
115          format.rate = 44100;          format.rate = 44100;
116          g_samplerate = pwfx->nSamplesPerSec;          format.byte_format = AO_FMT_NATIVE;
         format.byte_format = AO_FMT_LITTLE;  
   
         g_samplewidth = pwfx->wBitsPerSample / 8;  
117    
118          if (o_device != NULL)          if (o_device != NULL)
119                  ao_close(o_device);                  ao_close(o_device);
# Line 133  wave_out_set_format(WAVEFORMATEX * pwfx) Line 124  wave_out_set_format(WAVEFORMATEX * pwfx)
124                  return False;                  return False;
125          }          }
126    
127          g_reopened = True;          if (rdpsnd_dsp_resample_set(44100, pwfx->wBitsPerSample, pwfx->nChannels) == False)
   
         return True;  
 }  
   
 void  
 wave_out_volume(uint16 left, uint16 right)  
 {  
         warning("volume changes not supported with libao-output\n");  
 }  
   
 void  
 wave_out_write(STREAM s, uint16 tick, uint8 index)  
 {  
         struct audio_packet *packet = &packet_queue[queue_hi];  
         unsigned int next_hi = (queue_hi + 1) % MAX_QUEUE;  
   
         if (next_hi == queue_lo)  
128          {          {
129                  error("No space to queue audio packet\n");                  return False;
                 return;  
130          }          }
131    
132          queue_hi = next_hi;          reopened = True;
   
         packet->s = *s;  
         packet->tick = tick;  
         packet->index = index;  
         packet->s.p += 4;  
133    
134          /* we steal the data buffer from s, give it a new one */          return True;
         s->data = malloc(s->size);  
   
         if (!g_dsp_busy)  
                 wave_out_play();  
135  }  }
136    
137  void  void
138  wave_out_play(void)  libao_play(void)
139  {  {
140          struct audio_packet *packet;          struct audio_packet *packet;
141          STREAM out;          STREAM out;
142          unsigned char outbuf[WAVEOUTBUF];          int len;
         int offset, len, i;  
143          static long prev_s, prev_us;          static long prev_s, prev_us;
144          unsigned int duration;          unsigned int duration;
145          struct timeval tv;          struct timeval tv;
146          int next_tick;          int next_tick;
147    
148          if (g_reopened)          if (reopened)
149          {          {
150                  g_reopened = False;                  reopened = False;
151                  gettimeofday(&tv, NULL);                  gettimeofday(&tv, NULL);
152                  prev_s = tv.tv_sec;                  prev_s = tv.tv_sec;
153                  prev_us = tv.tv_usec;                  prev_us = tv.tv_usec;
154          }          }
155    
156          if (queue_lo == queue_hi)          /* We shouldn't be called if the queue is empty, but still */
157          {          if (rdpsnd_queue_empty())
                 g_dsp_busy = 0;  
158                  return;                  return;
         }  
159    
160          packet = &packet_queue[queue_lo];          packet = rdpsnd_queue_current_packet();
161          out = &packet->s;          out = &packet->s;
162    
163          if (((queue_lo + 1) % MAX_QUEUE) != queue_hi)          next_tick = rdpsnd_queue_next_tick();
         {  
                 next_tick = packet_queue[(queue_lo + 1) % MAX_QUEUE].tick;  
         }  
         else  
         {  
                 next_tick = (packet->tick + 65535) % 65536;  
         }  
   
         len = 0;  
   
         if (g_samplerate == 22050)  
         {  
                 /* Resample to 44100 */  
                 for (i = 0; (i < ((WAVEOUTBUF / 4) * (3 - g_samplewidth))) && (out->p < out->end);  
                      i++)  
                 {  
                         /* On a stereo-channel we must make sure that left and right  
                            does not get mixed up, so we need to expand the sample-  
                            data with channels in mind: 1234 -> 12123434  
                            If we have a mono-channel, we can expand the data by simply  
                            doubling the sample-data: 1234 -> 11223344 */  
                         if (g_channels == 2)  
                                 offset = ((i * 2) - (i & 1)) * g_samplewidth;  
                         else  
                                 offset = (i * 2) * g_samplewidth;  
   
                         memcpy(&outbuf[offset], out->p, g_samplewidth);  
                         memcpy(&outbuf[g_channels * g_samplewidth + offset], out->p, g_samplewidth);  
164    
165                          out->p += g_samplewidth;          len = (WAVEOUTLEN > (out->end - out->p)) ? (out->end - out->p) : WAVEOUTLEN;
166                          len += 2 * g_samplewidth;          ao_play(o_device, (char *) out->p, len);
167                  }          out->p += len;
         }  
         else  
         {  
                 len = (WAVEOUTBUF > (out->end - out->p)) ? (out->end - out->p) : WAVEOUTBUF;  
                 memcpy(outbuf, out->p, len);  
                 out->p += len;  
         }  
   
         ao_play(o_device, outbuf, len);  
168    
169          gettimeofday(&tv, NULL);          gettimeofday(&tv, NULL);
170    
# Line 251  wave_out_play(void) Line 175  wave_out_play(void)
175    
176          if ((out->p == out->end) || duration > next_tick - packet->tick + 500)          if ((out->p == out->end) || duration > next_tick - packet->tick + 500)
177          {          {
178                    unsigned int delay_us;
179    
180                  prev_s = tv.tv_sec;                  prev_s = tv.tv_sec;
181                  prev_us = tv.tv_usec;                  prev_us = tv.tv_usec;
182    
# Line 261  wave_out_play(void) Line 187  wave_out_play(void)
187                                 (packet->tick + duration) % 65536, next_tick % 65536));                                 (packet->tick + duration) % 65536, next_tick % 65536));
188                  }                  }
189    
190                  /* Until all drivers are using the windows sound-ticks, we need to                  delay_us = ((out->size / 4) * (1000000 / 44100));
191                     substract the 50 ticks added later by rdpsnd.c */  
192                  rdpsnd_send_completion(((packet->tick + duration) % 65536) - 50, packet->index);                  rdpsnd_queue_next(delay_us);
193                  free(out->data);          }
194                  queue_lo = (queue_lo + 1) % MAX_QUEUE;  }
195    
196    struct audio_driver *
197    libao_register(char *options)
198    {
199            static struct audio_driver libao_driver;
200    
201            memset(&libao_driver, 0, sizeof(libao_driver));
202    
203            libao_driver.name = "libao";
204            libao_driver.description = "libao output driver, default device: system dependent";
205    
206            libao_driver.add_fds = libao_add_fds;
207            libao_driver.check_fds = libao_check_fds;
208    
209            libao_driver.wave_out_open = libao_open;
210            libao_driver.wave_out_close = libao_close;
211            libao_driver.wave_out_format_supported = rdpsnd_dsp_resample_supported;
212            libao_driver.wave_out_set_format = libao_set_format;
213            libao_driver.wave_out_volume = rdpsnd_dsp_softvol_set;
214    
215            libao_driver.need_byteswap_on_be = 1;
216            libao_driver.need_resampling = 1;
217    
218            if (options)
219            {
220                    libao_device = xstrdup(options);
221          }          }
222    
223          g_dsp_busy = 1;          return &libao_driver;
         return;  
224  }  }
Legend:
Removed from v.963  
changed lines
  Added in v.1373
  ViewVC Help
Powered by ViewVC 1.1.26