/[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 836 by stargo, Tue Mar 8 12:09:20 2005 UTC revision 963 by astrand, Wed Aug 3 10:56:16 2005 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
# Line 25  Line 25 
25  #include <fcntl.h>  #include <fcntl.h>
26  #include <errno.h>  #include <errno.h>
27  #include <ao/ao.h>  #include <ao/ao.h>
28    #include <sys/time.h>
29    
30  #define MAX_QUEUE       10  #define MAX_QUEUE       10
31  #define WAVEOUTBUF      32  #define WAVEOUTBUF      64
32    
33  int g_dsp_fd;  int g_dsp_fd;
34  ao_device *o_device = NULL;  ao_device *o_device = NULL;
35  int default_driver;  int default_driver;
36  int g_samplerate;  int g_samplerate;
37    int g_channels;
38  BOOL g_dsp_busy = False;  BOOL g_dsp_busy = False;
39    static BOOL g_reopened;
40  static short g_samplewidth;  static short g_samplewidth;
41    
42  static struct audio_packet  static struct audio_packet
# Line 54  wave_out_open(void) Line 57  wave_out_open(void)
57    
58          format.bits = 16;          format.bits = 16;
59          format.channels = 2;          format.channels = 2;
60            g_channels = 2;
61          format.rate = 44100;          format.rate = 44100;
62          g_samplerate = 44100;          g_samplerate = 44100;
63          format.byte_format = AO_FMT_LITTLE;          format.byte_format = AO_FMT_LITTLE;
# Line 67  wave_out_open(void) Line 71  wave_out_open(void)
71          g_dsp_fd = 0;          g_dsp_fd = 0;
72          queue_lo = queue_hi = 0;          queue_lo = queue_hi = 0;
73    
74            g_reopened = True;
75    
76          return True;          return True;
77  }  }
78    
# Line 83  wave_out_close(void) Line 89  wave_out_close(void)
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    
# Line 110  wave_out_set_format(WAVEFORMATEX * pwfx) Line 117  wave_out_set_format(WAVEFORMATEX * pwfx)
117    
118          format.bits = pwfx->wBitsPerSample;          format.bits = pwfx->wBitsPerSample;
119          format.channels = pwfx->nChannels;          format.channels = pwfx->nChannels;
120            g_channels = pwfx->nChannels;
121          format.rate = 44100;          format.rate = 44100;
122          g_samplerate = pwfx->nSamplesPerSec;          g_samplerate = pwfx->nSamplesPerSec;
123          format.byte_format = AO_FMT_LITTLE;          format.byte_format = AO_FMT_LITTLE;
124    
125          g_samplewidth = pwfx->wBitsPerSample / 8;          g_samplewidth = pwfx->wBitsPerSample / 8;
126    
127          if(o_device != NULL)          if (o_device != NULL)
128                  ao_close(o_device);                  ao_close(o_device);
129    
130          o_device = ao_open_live(default_driver, &format, NULL);          o_device = ao_open_live(default_driver, &format, NULL);
# Line 125  wave_out_set_format(WAVEFORMATEX * pwfx) Line 133  wave_out_set_format(WAVEFORMATEX * pwfx)
133                  return False;                  return False;
134          }          }
135    
136            g_reopened = True;
137    
138          return True;          return True;
139  }  }
# Line 132  wave_out_set_format(WAVEFORMATEX * pwfx) Line 141  wave_out_set_format(WAVEFORMATEX * pwfx)
141  void  void
142  wave_out_volume(uint16 left, uint16 right)  wave_out_volume(uint16 left, uint16 right)
143  {  {
144            warning("volume changes not supported with libao-output\n");
145  }  }
146    
147  void  void
# Line 165  wave_out_play(void) Line 175  wave_out_play(void)
175  {  {
176          struct audio_packet *packet;          struct audio_packet *packet;
177          STREAM out;          STREAM out;
178          unsigned char expanded[WAVEOUTBUF];          unsigned char outbuf[WAVEOUTBUF];
179          int offset,len,i;          int offset, len, i;
180            static long prev_s, prev_us;
181            unsigned int duration;
182            struct timeval tv;
183            int next_tick;
184    
185            if (g_reopened)
186            {
187                    g_reopened = False;
188                    gettimeofday(&tv, NULL);
189                    prev_s = tv.tv_sec;
190                    prev_us = tv.tv_usec;
191            }
192    
193          if (queue_lo == queue_hi)          if (queue_lo == queue_hi)
194          {          {
# Line 177  wave_out_play(void) Line 199  wave_out_play(void)
199          packet = &packet_queue[queue_lo];          packet = &packet_queue[queue_lo];
200          out = &packet->s;          out = &packet->s;
201    
202            if (((queue_lo + 1) % MAX_QUEUE) != queue_hi)
203            {
204                    next_tick = packet_queue[(queue_lo + 1) % MAX_QUEUE].tick;
205            }
206            else
207            {
208                    next_tick = (packet->tick + 65535) % 65536;
209            }
210    
211          len = 0;          len = 0;
212    
213          if (g_samplerate == 22050 )          if (g_samplerate == 22050)
214          {          {
215                  /* Resample to 44100 */                  /* Resample to 44100 */
216                  for(i=0; (i<((WAVEOUTBUF/8)*(3-g_samplewidth))) && (out->p < out->end); i++)                  for (i = 0; (i < ((WAVEOUTBUF / 4) * (3 - g_samplewidth))) && (out->p < out->end);
217                         i++)
218                  {                  {
219                          offset=i*4*g_samplewidth;                          /* On a stereo-channel we must make sure that left and right
220                          memcpy(&expanded[0*g_samplewidth+offset],out->p,g_samplewidth);                             does not get mixed up, so we need to expand the sample-
221                          memcpy(&expanded[2*g_samplewidth+offset],out->p,g_samplewidth);                             data with channels in mind: 1234 -> 12123434
222                          out->p += 2;                             If we have a mono-channel, we can expand the data by simply
223                               doubling the sample-data: 1234 -> 11223344 */
224                          memcpy(&expanded[1*g_samplewidth+offset],out->p,g_samplewidth);                          if (g_channels == 2)
225                          memcpy(&expanded[3*g_samplewidth+offset],out->p,g_samplewidth);                                  offset = ((i * 2) - (i & 1)) * g_samplewidth;
226                          out->p += 2;                          else
227                          len += 4*g_samplewidth;                                  offset = (i * 2) * g_samplewidth;
228    
229                            memcpy(&outbuf[offset], out->p, g_samplewidth);
230                            memcpy(&outbuf[g_channels * g_samplewidth + offset], out->p, g_samplewidth);
231    
232                            out->p += g_samplewidth;
233                            len += 2 * g_samplewidth;
234                  }                  }
235          }          }
236          else          else
237          {          {
238                  len = (WAVEOUTBUF > (out->end - out->p)) ? (out->end - out->p) : WAVEOUTBUF;                  len = (WAVEOUTBUF > (out->end - out->p)) ? (out->end - out->p) : WAVEOUTBUF;
239                  memcpy(expanded,out->p,len);                  memcpy(outbuf, out->p, len);
240                  out->p += len;                  out->p += len;
241          }          }
242    
243          ao_play(o_device, expanded, len);          ao_play(o_device, outbuf, len);
244    
245            gettimeofday(&tv, NULL);
246    
247            duration = ((tv.tv_sec - prev_s) * 1000000 + (tv.tv_usec - prev_us)) / 1000;
248    
249          if (out->p == out->end)          if (packet->tick > next_tick)
250                    next_tick += 65536;
251    
252            if ((out->p == out->end) || duration > next_tick - packet->tick + 500)
253          {          {
254                  rdpsnd_send_completion(packet->tick, packet->index);                  prev_s = tv.tv_sec;
255                    prev_us = tv.tv_usec;
256    
257                    if (abs((next_tick - packet->tick) - duration) > 20)
258                    {
259                            DEBUG(("duration: %d, calc: %d, ", duration, next_tick - packet->tick));
260                            DEBUG(("last: %d, is: %d, should: %d\n", packet->tick,
261                                   (packet->tick + duration) % 65536, next_tick % 65536));
262                    }
263    
264                    /* Until all drivers are using the windows sound-ticks, we need to
265                       substract the 50 ticks added later by rdpsnd.c */
266                    rdpsnd_send_completion(((packet->tick + duration) % 65536) - 50, packet->index);
267                  free(out->data);                  free(out->data);
268                  queue_lo = (queue_lo + 1) % MAX_QUEUE;                  queue_lo = (queue_lo + 1) % MAX_QUEUE;
269          }          }
Legend:
Removed from v.836  
changed lines
  Added in v.963
  ViewVC Help
Powered by ViewVC 1.1.26