/[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 1279 by stargo, Sun Oct 1 14:03:43 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 BOOL reopened;
37  int g_samplerate;  static char *libao_device = NULL;
 BOOL g_dsp_busy = False;  
 static short g_samplewidth;  
   
 static struct audio_packet  
 {  
         struct stream s;  
         uint16 tick;  
         uint8 index;  
 } packet_queue[MAX_QUEUE];  
 static unsigned int queue_hi, queue_lo;  
38    
39  BOOL  BOOL
40  wave_out_open(void)  libao_open(void)
41  {  {
42          ao_sample_format format;          ao_sample_format format;
43    
44          ao_initialize();          ao_initialize();
45          default_driver = ao_default_driver_id();  
46            if (libao_device)
47            {
48                    default_driver = ao_driver_id(libao_device);
49            }
50            else
51            {
52                    default_driver = ao_default_driver_id();
53            }
54    
55          format.bits = 16;          format.bits = 16;
56          format.channels = 2;          format.channels = 2;
57          format.rate = 44100;          format.rate = 44100;
         g_samplerate = 44100;  
58          format.byte_format = AO_FMT_LITTLE;          format.byte_format = AO_FMT_LITTLE;
59    
60          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 64  wave_out_open(void)
64          }          }
65    
66          g_dsp_fd = 0;          g_dsp_fd = 0;
67          queue_lo = queue_hi = 0;          rdpsnd_queue_init();
68    
69            reopened = True;
70    
71          return True;          return True;
72  }  }
73    
74  void  void
75  wave_out_close(void)  libao_close(void)
76  {  {
77          /* Ack all remaining packets */          /* Ack all remaining packets */
78          while (queue_lo != queue_hi)          while (!rdpsnd_queue_empty())
79          {          {
80                  rdpsnd_send_completion(packet_queue[queue_lo].tick, packet_queue[queue_lo].index);                  rdpsnd_send_completion(rdpsnd_queue_current_packet()->tick,
81                  free(packet_queue[queue_lo].s.data);                                         rdpsnd_queue_current_packet()->index);
82                  queue_lo = (queue_lo + 1) % MAX_QUEUE;                  rdpsnd_queue_next();
83          }          }
84    
85          if (o_device != NULL)          if (o_device != NULL)
86                  ao_close(o_device);                  ao_close(o_device);
         ao_shutdown();  
 }  
   
 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;  
87    
88          return True;          ao_shutdown();
89  }  }
90    
91  BOOL  BOOL
92  wave_out_set_format(WAVEFORMATEX * pwfx)  libao_set_format(WAVEFORMATEX * pwfx)
93  {  {
94          ao_sample_format format;          ao_sample_format format;
95    
96          format.bits = pwfx->wBitsPerSample;          format.bits = pwfx->wBitsPerSample;
97          format.channels = pwfx->nChannels;          format.channels = pwfx->nChannels;
98          format.rate = 44100;          format.rate = 44100;
         g_samplerate = pwfx->nSamplesPerSec;  
99          format.byte_format = AO_FMT_LITTLE;          format.byte_format = AO_FMT_LITTLE;
100    
         g_samplewidth = pwfx->wBitsPerSample / 8;  
   
101          if (o_device != NULL)          if (o_device != NULL)
102                  ao_close(o_device);                  ao_close(o_device);
103    
# Line 125  wave_out_set_format(WAVEFORMATEX * pwfx) Line 107  wave_out_set_format(WAVEFORMATEX * pwfx)
107                  return False;                  return False;
108          }          }
109    
110            if (rdpsnd_dsp_resample_set(44100, pwfx->wBitsPerSample, pwfx->nChannels) == False)
111            {
112                    return False;
113            }
114    
115            reopened = True;
116    
117          return True;          return True;
118  }  }
119    
120  void  void
121  wave_out_volume(uint16 left, uint16 right)  libao_play(void)
122  {  {
123  }          struct audio_packet *packet;
124            STREAM out;
125            int len;
126            static long prev_s, prev_us;
127            unsigned int duration;
128            struct timeval tv;
129            int next_tick;
130    
131  void          if (reopened)
132  wave_out_write(STREAM s, uint16 tick, uint8 index)          {
133  {                  reopened = False;
134          struct audio_packet *packet = &packet_queue[queue_hi];                  gettimeofday(&tv, NULL);
135          unsigned int next_hi = (queue_hi + 1) % MAX_QUEUE;                  prev_s = tv.tv_sec;
136                    prev_us = tv.tv_usec;
137            }
138    
139          if (next_hi == queue_lo)          if (rdpsnd_queue_empty())
140          {          {
141                  error("No space to queue audio packet\n");                  g_dsp_busy = 0;
142                  return;                  return;
143          }          }
144    
145          queue_hi = next_hi;          packet = rdpsnd_queue_current_packet();
146            out = &packet->s;
147    
148          packet->s = *s;          next_tick = rdpsnd_queue_next_tick();
         packet->tick = tick;  
         packet->index = index;  
         packet->s.p += 4;  
149    
150          /* we steal the data buffer from s, give it a new one */          len = (WAVEOUTBUF > (out->end - out->p)) ? (out->end - out->p) : WAVEOUTBUF;
151          s->data = malloc(s->size);          ao_play(o_device, (char *) out->p, len);
152            out->p += len;
153    
154          if (!g_dsp_busy)          gettimeofday(&tv, NULL);
                 wave_out_play();  
 }  
155    
156  void          duration = ((tv.tv_sec - prev_s) * 1000000 + (tv.tv_usec - prev_us)) / 1000;
157  wave_out_play(void)  
158  {          if (packet->tick > next_tick)
159          struct audio_packet *packet;                  next_tick += 65536;
         STREAM out;  
         unsigned char outbuf[WAVEOUTBUF];  
         int offset, len, i;  
160    
161          if (queue_lo == queue_hi)          if ((out->p == out->end) || duration > next_tick - packet->tick + 500)
162          {          {
163                  g_dsp_busy = 0;                  prev_s = tv.tv_sec;
164                  return;                  prev_us = tv.tv_usec;
165    
166                    if (abs((next_tick - packet->tick) - duration) > 20)
167                    {
168                            DEBUG(("duration: %d, calc: %d, ", duration, next_tick - packet->tick));
169                            DEBUG(("last: %d, is: %d, should: %d\n", packet->tick,
170                                   (packet->tick + duration) % 65536, next_tick % 65536));
171                    }
172    
173                    rdpsnd_send_completion(((packet->tick + duration) % 65536), packet->index);
174                    rdpsnd_queue_next();
175          }          }
176    
177          packet = &packet_queue[queue_lo];          g_dsp_busy = 1;
178          out = &packet->s;          return;
179    }
180    
181    struct audio_driver *
182    libao_register(char *options)
183    {
184            static struct audio_driver libao_driver;
185            struct ao_info *libao_info;
186            static char description[101];
187    
188            libao_driver.wave_out_write = rdpsnd_queue_write;
189            libao_driver.wave_out_open = libao_open;
190            libao_driver.wave_out_close = libao_close;
191            libao_driver.wave_out_format_supported = rdpsnd_dsp_resample_supported;
192            libao_driver.wave_out_set_format = libao_set_format;
193            libao_driver.wave_out_volume = rdpsnd_dsp_softvol_set;
194            libao_driver.wave_out_play = libao_play;
195            libao_driver.name = xstrdup("libao");
196            libao_driver.description = description;
197            libao_driver.need_byteswap_on_be = 0;
198            libao_driver.need_resampling = 1;
199            libao_driver.next = NULL;
200    
201          len = 0;          ao_initialize();
202    
203            libao_info = ao_driver_info(ao_default_driver_id());
204    
205          if (g_samplerate == 22050)          if (libao_info)
206          {          {
207                  /* Resample to 44100 */                  snprintf(description, 100, "libao output driver, default device: %s",
208                  for (i = 0; (i < ((WAVEOUTBUF / 8) * (3 - g_samplewidth))) && (out->p < out->end);                           libao_info->short_name);
                      i++)  
                 {  
                         offset = i * 4 * g_samplewidth;  
                         memcpy(&outbuf[0 * g_samplewidth + offset], out->p, g_samplewidth);  
                         memcpy(&outbuf[2 * g_samplewidth + offset], out->p, g_samplewidth);  
                         out->p += 2;  
   
                         memcpy(&outbuf[1 * g_samplewidth + offset], out->p, g_samplewidth);  
                         memcpy(&outbuf[3 * g_samplewidth + offset], out->p, g_samplewidth);  
                         out->p += 2;  
                         len += 4 * g_samplewidth;  
                 }  
209          }          }
210          else          else
211          {          {
212                  len = (WAVEOUTBUF > (out->end - out->p)) ? (out->end - out->p) : WAVEOUTBUF;                  snprintf(description, 100, "libao output driver, default device: none");
                 memcpy(outbuf, out->p, len);  
                 out->p += len;  
213          }          }
214    
215          ao_play(o_device, outbuf, len);          ao_shutdown();
216    
217          if (out->p == out->end)          if (options)
218          {          {
219                  rdpsnd_send_completion(packet->tick, packet->index);                  libao_device = xstrdup(options);
                 free(out->data);  
                 queue_lo = (queue_lo + 1) % MAX_QUEUE;  
220          }          }
221    
222          g_dsp_busy = 1;          return &libao_driver;
         return;  
223  }  }
Legend:
Removed from v.837  
changed lines
  Added in v.1279
  ViewVC Help
Powered by ViewVC 1.1.26