/[rdesktop]/sourceforge.net/trunk/rdesktop/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 /sourceforge.net/trunk/rdesktop/rdpsnd_libao.c

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

revision 837 by stargo, Tue Mar 8 12:16:22 2005 UTC revision 1268 by stargo, Mon Sep 18 09:34:34 2006 UTC
# Line 1  Line 1 
1  /*  /* -*- 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
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-2006
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>
31    
32  #define MAX_QUEUE       10  #define WAVEOUTBUF      16
 #define WAVEOUTBUF      32  
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 int samplerate;
37  int g_samplerate;  static int audiochannels;
38  BOOL g_dsp_busy = False;  static BOOL reopened;
39  static short g_samplewidth;  static short samplewidth;
40    static char *libao_device = NULL;
 static struct audio_packet  
 {  
         struct stream s;  
         uint16 tick;  
         uint8 index;  
 } packet_queue[MAX_QUEUE];  
 static unsigned int queue_hi, queue_lo;  
41    
42  BOOL  BOOL
43  wave_out_open(void)  libao_open(void)
44  {  {
45          ao_sample_format format;          ao_sample_format format;
46    
47          ao_initialize();          ao_initialize();
48          default_driver = ao_default_driver_id();  
49            if (libao_device)
50            {
51                    default_driver = ao_driver_id(libao_device);
52            }
53            else
54            {
55                    default_driver = ao_default_driver_id();
56            }
57    
58          format.bits = 16;          format.bits = 16;
59          format.channels = 2;          format.channels = 2;
60            audiochannels = 2;
61          format.rate = 44100;          format.rate = 44100;
62          g_samplerate = 44100;          samplerate = 44100;
63          format.byte_format = AO_FMT_LITTLE;          format.byte_format = AO_FMT_LITTLE;
64    
65          o_device = ao_open_live(default_driver, &format, NULL);          o_device = ao_open_live(default_driver, &format, NULL);
# Line 65  wave_out_open(void) Line 69  wave_out_open(void)
69          }          }
70    
71          g_dsp_fd = 0;          g_dsp_fd = 0;
72          queue_lo = queue_hi = 0;          rdpsnd_queue_init();
73    
74            reopened = True;
75    
76          return True;          return True;
77  }  }
78    
79  void  void
80  wave_out_close(void)  libao_close(void)
81  {  {
82          /* Ack all remaining packets */          /* Ack all remaining packets */
83          while (queue_lo != queue_hi)          while (!rdpsnd_queue_empty())
84          {          {
85                  rdpsnd_send_completion(packet_queue[queue_lo].tick, packet_queue[queue_lo].index);                  rdpsnd_send_completion(rdpsnd_queue_current_packet()->tick,
86                  free(packet_queue[queue_lo].s.data);                                         rdpsnd_queue_current_packet()->index);
87                  queue_lo = (queue_lo + 1) % MAX_QUEUE;                  rdpsnd_queue_next();
88          }          }
89    
90          if (o_device != NULL)          if (o_device != NULL)
91                  ao_close(o_device);                  ao_close(o_device);
92    
93          ao_shutdown();          ao_shutdown();
94  }  }
95    
96  BOOL  BOOL
97  wave_out_format_supported(WAVEFORMATEX * pwfx)  libao_format_supported(WAVEFORMATEX * pwfx)
98  {  {
99          if (pwfx->wFormatTag != WAVE_FORMAT_PCM)          if (pwfx->wFormatTag != WAVE_FORMAT_PCM)
100                  return False;                  return False;
# Line 104  wave_out_format_supported(WAVEFORMATEX * Line 111  wave_out_format_supported(WAVEFORMATEX *
111  }  }
112    
113  BOOL  BOOL
114  wave_out_set_format(WAVEFORMATEX * pwfx)  libao_set_format(WAVEFORMATEX * pwfx)
115  {  {
116          ao_sample_format format;          ao_sample_format format;
117    
118          format.bits = pwfx->wBitsPerSample;          format.bits = pwfx->wBitsPerSample;
119          format.channels = pwfx->nChannels;          format.channels = pwfx->nChannels;
120            audiochannels = pwfx->nChannels;
121          format.rate = 44100;          format.rate = 44100;
122          g_samplerate = pwfx->nSamplesPerSec;          samplerate = pwfx->nSamplesPerSec;
123          format.byte_format = AO_FMT_LITTLE;          format.byte_format = AO_FMT_LITTLE;
124    
125          g_samplewidth = pwfx->wBitsPerSample / 8;          samplewidth = pwfx->wBitsPerSample / 8;
126    
127          if (o_device != NULL)          if (o_device != NULL)
128                  ao_close(o_device);                  ao_close(o_device);
# Line 125  wave_out_set_format(WAVEFORMATEX * pwfx) Line 133  wave_out_set_format(WAVEFORMATEX * pwfx)
133                  return False;                  return False;
134          }          }
135    
136            reopened = True;
137    
138          return True;          return True;
139  }  }
140    
141  void  void
142  wave_out_volume(uint16 left, uint16 right)  libao_play(void)
 {  
 }  
   
 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)  
         {  
                 error("No space to queue audio packet\n");  
                 return;  
         }  
   
         queue_hi = next_hi;  
   
         packet->s = *s;  
         packet->tick = tick;  
         packet->index = index;  
         packet->s.p += 4;  
   
         /* we steal the data buffer from s, give it a new one */  
         s->data = malloc(s->size);  
   
         if (!g_dsp_busy)  
                 wave_out_play();  
 }  
   
 void  
 wave_out_play(void)  
143  {  {
144          struct audio_packet *packet;          struct audio_packet *packet;
145          STREAM out;          STREAM out;
146          unsigned char outbuf[WAVEOUTBUF];          char outbuf[WAVEOUTBUF];
147          int offset, len, i;          int offset, len, i;
148            static long prev_s, prev_us;
149            unsigned int duration;
150            struct timeval tv;
151            int next_tick;
152    
153          if (queue_lo == queue_hi)          if (reopened)
154            {
155                    reopened = False;
156                    gettimeofday(&tv, NULL);
157                    prev_s = tv.tv_sec;
158                    prev_us = tv.tv_usec;
159            }
160    
161            if (rdpsnd_queue_empty())
162          {          {
163                  g_dsp_busy = 0;                  g_dsp_busy = 0;
164                  return;                  return;
165          }          }
166    
167          packet = &packet_queue[queue_lo];          packet = rdpsnd_queue_current_packet();
168          out = &packet->s;          out = &packet->s;
169    
170            next_tick = rdpsnd_queue_next_tick();
171    
172          len = 0;          len = 0;
173    
174          if (g_samplerate == 22050)          if (samplerate == 22050)
175          {          {
176                  /* Resample to 44100 */                  /* Resample to 44100 */
177                  for (i = 0; (i < ((WAVEOUTBUF / 8) * (3 - g_samplewidth))) && (out->p < out->end);                  for (i = 0; (i < ((WAVEOUTBUF / 4) * (3 - samplewidth))) && (out->p < out->end);
178                       i++)                       i++)
179                  {                  {
180                          offset = i * 4 * g_samplewidth;                          /* On a stereo-channel we must make sure that left and right
181                          memcpy(&outbuf[0 * g_samplewidth + offset], out->p, g_samplewidth);                             does not get mixed up, so we need to expand the sample-
182                          memcpy(&outbuf[2 * g_samplewidth + offset], out->p, g_samplewidth);                             data with channels in mind: 1234 -> 12123434
183                          out->p += 2;                             If we have a mono-channel, we can expand the data by simply
184                               doubling the sample-data: 1234 -> 11223344 */
185                          memcpy(&outbuf[1 * g_samplewidth + offset], out->p, g_samplewidth);                          if (audiochannels == 2)
186                          memcpy(&outbuf[3 * g_samplewidth + offset], out->p, g_samplewidth);                                  offset = ((i * 2) - (i & 1)) * samplewidth;
187                          out->p += 2;                          else
188                          len += 4 * g_samplewidth;                                  offset = (i * 2) * samplewidth;
189    
190                            memcpy(&outbuf[offset], out->p, samplewidth);
191                            memcpy(&outbuf[audiochannels * samplewidth + offset], out->p, samplewidth);
192    
193                            out->p += samplewidth;
194                            len += 2 * samplewidth;
195                  }                  }
196          }          }
197          else          else
# Line 205  wave_out_play(void) Line 203  wave_out_play(void)
203    
204          ao_play(o_device, outbuf, len);          ao_play(o_device, outbuf, len);
205    
206          if (out->p == out->end)          gettimeofday(&tv, NULL);
207    
208            duration = ((tv.tv_sec - prev_s) * 1000000 + (tv.tv_usec - prev_us)) / 1000;
209    
210            if (packet->tick > next_tick)
211                    next_tick += 65536;
212    
213            if ((out->p == out->end) || duration > next_tick - packet->tick + 500)
214          {          {
215                  rdpsnd_send_completion(packet->tick, packet->index);                  prev_s = tv.tv_sec;
216                  free(out->data);                  prev_us = tv.tv_usec;
217                  queue_lo = (queue_lo + 1) % MAX_QUEUE;  
218                    if (abs((next_tick - packet->tick) - duration) > 20)
219                    {
220                            DEBUG(("duration: %d, calc: %d, ", duration, next_tick - packet->tick));
221                            DEBUG(("last: %d, is: %d, should: %d\n", packet->tick,
222                                   (packet->tick + duration) % 65536, next_tick % 65536));
223                    }
224    
225                    rdpsnd_send_completion(((packet->tick + duration) % 65536), packet->index);
226                    rdpsnd_queue_next();
227          }          }
228    
229          g_dsp_busy = 1;          g_dsp_busy = 1;
230          return;          return;
231  }  }
232    
233    struct audio_driver *
234    libao_register(char *options)
235    {
236            static struct audio_driver libao_driver;
237            struct ao_info *libao_info;
238            static char description[101];
239    
240            libao_driver.wave_out_write = rdpsnd_queue_write;
241            libao_driver.wave_out_open = libao_open;
242            libao_driver.wave_out_close = libao_close;
243            libao_driver.wave_out_format_supported = libao_format_supported;
244            libao_driver.wave_out_set_format = libao_set_format;
245            libao_driver.wave_out_volume = rdpsnd_dsp_softvol_set;
246            libao_driver.wave_out_play = libao_play;
247            libao_driver.name = xstrdup("libao");
248            libao_driver.description = description;
249            libao_driver.need_byteswap_on_be = 0;
250            libao_driver.next = NULL;
251    
252            ao_initialize();
253    
254            libao_info = ao_driver_info(ao_default_driver_id());
255    
256            if (libao_info)
257            {
258                    snprintf(description, 100, "libao output driver, default device: %s",
259                                    libao_info->short_name);
260            }
261            else
262            {
263                    snprintf(description, 100, "libao output driver, default device: none");
264            }
265    
266            ao_shutdown();
267    
268            if (options)
269            {
270                    libao_device = xstrdup(options);
271            }
272    
273            return &libao_driver;
274    }
Legend:
Removed from v.837  
changed lines
  Added in v.1268
  ViewVC Help
Powered by ViewVC 1.1.26