user32: Pre-allocate the window procedure for the MDI client class.
[wine] / dlls / winejack.drv / audio.c
1 /*
2  * Wine Driver for jack Sound Server
3  *   http://jackit.sourceforge.net
4  *
5  * Copyright 1994 Martin Ayotte
6  * Copyright 1999 Eric Pouech (async playing in waveOut/waveIn)
7  * Copyright 2000 Eric Pouech (loops in waveOut)
8  * Copyright 2002 Chris Morgan (jack version of this file)
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with this library; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23  */
24
25 /*
26  * TODO:
27  *  implement audio stream resampling for any arbitrary frequenty
28  *    right now we use the winmm layer to do resampling although it would 
29  *    be nice to have a full set of algorithms to choose from based on cpu 
30  *    time
31  *
32  * FIXME:
33  *  pause in waveOut during loop is not handled correctly
34  */
35
36 #include "config.h"
37
38 #include <stdlib.h>
39 #include <stdarg.h>
40 #include <stdio.h>
41 #include <string.h>
42 #ifdef HAVE_UNISTD_H
43 # include <unistd.h>
44 #endif
45 #include <fcntl.h>
46 #include "windef.h"
47 #include "winbase.h"
48 #include "winnls.h"
49 #include "wingdi.h"
50 #include "winerror.h"
51 #include "mmddk.h"
52 #include "dsound.h"
53 #include "dsdriver.h"
54 #include "jack.h"
55 #include "wine/unicode.h"
56 #include "wine/library.h"
57 #include "wine/debug.h"
58
59 #ifdef HAVE_JACK_JACK_H
60 #include <jack/jack.h>
61 #endif
62
63
64 WINE_DEFAULT_DEBUG_CHANNEL(wave);
65
66 #ifdef SONAME_LIBJACK
67
68 #define MAKE_FUNCPTR(f) static typeof(f) * fp_##f = NULL;
69
70 /* Function pointers for dynamic loading of libjack */
71 /* these are prefixed with "fp_", ie. "fp_jack_client_new" */
72 MAKE_FUNCPTR(jack_activate);
73 MAKE_FUNCPTR(jack_connect);
74 MAKE_FUNCPTR(jack_client_new);
75 MAKE_FUNCPTR(jack_client_close);
76 MAKE_FUNCPTR(jack_deactivate);
77 MAKE_FUNCPTR(jack_set_process_callback);
78 MAKE_FUNCPTR(jack_set_buffer_size_callback);
79 MAKE_FUNCPTR(jack_set_sample_rate_callback);
80 MAKE_FUNCPTR(jack_on_shutdown);
81 MAKE_FUNCPTR(jack_get_sample_rate);
82 MAKE_FUNCPTR(jack_port_register);
83 MAKE_FUNCPTR(jack_port_get_buffer);
84 MAKE_FUNCPTR(jack_get_ports);
85 MAKE_FUNCPTR(jack_port_name);
86 MAKE_FUNCPTR(jack_get_buffer_size);
87 #undef MAKE_FUNCPTR
88
89 /* define the below to work around a bug in jack where closing a port */
90 /* takes a very long time, so to get around this we actually don't */
91 /* close the port when the device is closed but instead mark the */
92 /* corresponding device as unused */
93 #define JACK_CLOSE_HACK    1
94
95 typedef jack_default_audio_sample_t sample_t;
96 typedef jack_nframes_t nframes_t;
97
98 /* only allow 10 output devices through this driver, this ought to be adequate */
99 #define MAX_WAVEOUTDRV  (10)
100 #define MAX_WAVEINDRV   (10)
101
102 /* state diagram for waveOut writing:
103  *
104  * +---------+-------------+---------------+---------------------------------+
105  * |  state  |  function   |     event     |            new state            |
106  * +---------+-------------+---------------+---------------------------------+
107  * |         | open()      |               | STOPPED                         |
108  * | PAUSED  | write()     |               | PAUSED                          |
109  * | STOPPED | write()     | <thrd create> | PLAYING                         |
110  * | PLAYING | write()     | HEADER        | PLAYING                         |
111  * | (other) | write()     | <error>       |                                 |
112  * | (any)   | pause()     | PAUSING       | PAUSED                          |
113  * | PAUSED  | restart()   | RESTARTING    | PLAYING (if no thrd => STOPPED) |
114  * | (any)   | reset()     | RESETTING     | STOPPED                         |
115  * | (any)   | close()     | CLOSING       | CLOSED                          |
116  * +---------+-------------+---------------+---------------------------------+
117  */
118
119 /* states of the playing device */
120 #define WINE_WS_PLAYING   0
121 #define WINE_WS_PAUSED    1
122 #define WINE_WS_STOPPED   2
123 #define WINE_WS_CLOSED    3
124
125 typedef struct {
126     volatile int      state;      /* one of the WINE_WS_ manifest constants */
127     WAVEOPENDESC      waveDesc;
128     WORD              wFlags;
129     PCMWAVEFORMAT     format;
130     WAVEOUTCAPSW      caps;
131     WORD              wDevID;
132     char              interface_name[32];
133
134     jack_port_t*      out_port_l;   /* ports for left and right channels */
135     jack_port_t*      out_port_r;
136     jack_client_t*    client;
137     long              sample_rate;        /* jack server sample rate */
138
139 #if JACK_CLOSE_HACK
140     BOOL              in_use; /* TRUE if this device is in use */
141 #endif
142
143     char*             sound_buffer;
144     unsigned long     buffer_size;
145
146     DWORD             volume_left;
147     DWORD             volume_right;
148
149     LPWAVEHDR         lpQueuePtr;   /* start of queued WAVEHDRs (waiting to be notified) */
150     LPWAVEHDR         lpPlayPtr;    /* start of not yet fully played buffers */
151     DWORD             dwPartialOffset;  /* Offset of not yet written bytes in lpPlayPtr */
152
153     LPWAVEHDR         lpLoopPtr;    /* pointer of first buffer in loop, if any */
154     DWORD             dwLoops;      /* private copy of loop counter */
155     
156     DWORD             dwPlayedTotal;    /* number of bytes actually played since opening */
157     DWORD             dwWrittenTotal;   /* number of bytes written to jack since opening */
158
159     DWORD             bytesInJack; /* bytes that we wrote during the previous JACK_Callback() */
160     DWORD             tickCountMS; /* time in MS of last JACK_Callback() */
161
162     /* synchronization stuff */
163     CRITICAL_SECTION    access_crst;
164 } WINE_WAVEOUT;
165
166 typedef struct {
167     volatile int    state;
168     WAVEOPENDESC    waveDesc;
169     WORD            wFlags;
170     PCMWAVEFORMAT   format;
171     LPWAVEHDR       lpQueuePtr;
172     DWORD           dwTotalRecorded;
173     WAVEINCAPSW     caps;
174     BOOL            bTriggerSupport;
175     WORD              wDevID;
176     char              interface_name[32];
177
178     jack_port_t*      in_port_l;   /* ports for left and right channels */
179     jack_port_t*      in_port_r;
180     jack_client_t*    client;
181     long              sample_rate;        /* jack server sample rate */
182
183 #if JACK_CLOSE_HACK
184     BOOL              in_use; /* TRUE if this device is in use */
185 #endif
186
187     char*             sound_buffer;
188     unsigned long     buffer_size;
189
190     /* synchronization stuff */
191     CRITICAL_SECTION    access_crst;
192 } WINE_WAVEIN;
193
194 static WINE_WAVEOUT WOutDev   [MAX_WAVEOUTDRV];
195 static WINE_WAVEIN  WInDev    [MAX_WAVEINDRV ];
196
197 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv);
198 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc);
199
200 static LPWAVEHDR wodHelper_PlayPtrNext(WINE_WAVEOUT* wwo);
201 static DWORD wodHelper_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force);
202
203 static int JACK_OpenWaveOutDevice(WINE_WAVEOUT* wwo);
204 static int JACK_OpenWaveInDevice(WINE_WAVEIN* wwi, WORD nChannels);
205
206 #if JACK_CLOSE_HACK
207 static void     JACK_CloseWaveOutDevice(WINE_WAVEOUT* wwo, BOOL close_client);
208 #else
209 static void     JACK_CloseWaveOutDevice(WINE_WAVEOUT* wwo);
210 #endif
211
212 #if JACK_CLOSE_HACK
213 static void     JACK_CloseWaveInDevice(WINE_WAVEIN* wwi, BOOL close_client);
214 #else
215 static void     JACK_CloseWaveInDevice(WINE_WAVEIN* wwi);
216 #endif
217
218 static DWORD bytes_to_mmtime(LPMMTIME lpTime, DWORD position,
219                              PCMWAVEFORMAT* format)
220 {
221     TRACE("wType=%04X wBitsPerSample=%u nSamplesPerSec=%u nChannels=%u nAvgBytesPerSec=%u\n",
222           lpTime->wType, format->wBitsPerSample, format->wf.nSamplesPerSec,
223           format->wf.nChannels, format->wf.nAvgBytesPerSec);
224     TRACE("Position in bytes=%u\n", position);
225
226     switch (lpTime->wType) {
227     case TIME_SAMPLES:
228         lpTime->u.sample = position / (format->wBitsPerSample / 8 * format->wf.nChannels);
229         TRACE("TIME_SAMPLES=%u\n", lpTime->u.sample);
230         break;
231     case TIME_MS:
232         lpTime->u.ms = 1000.0 * position / (format->wBitsPerSample / 8 * format->wf.nChannels * format->wf.nSamplesPerSec);
233         TRACE("TIME_MS=%u\n", lpTime->u.ms);
234         break;
235     case TIME_SMPTE:
236         lpTime->u.smpte.fps = 30;
237         position = position / (format->wBitsPerSample / 8 * format->wf.nChannels);
238         position += (format->wf.nSamplesPerSec / lpTime->u.smpte.fps) - 1; /* round up */
239         lpTime->u.smpte.sec = position / format->wf.nSamplesPerSec;
240         position -= lpTime->u.smpte.sec * format->wf.nSamplesPerSec;
241         lpTime->u.smpte.min = lpTime->u.smpte.sec / 60;
242         lpTime->u.smpte.sec -= 60 * lpTime->u.smpte.min;
243         lpTime->u.smpte.hour = lpTime->u.smpte.min / 60;
244         lpTime->u.smpte.min -= 60 * lpTime->u.smpte.hour;
245         lpTime->u.smpte.fps = 30;
246         lpTime->u.smpte.frame = position * lpTime->u.smpte.fps / format->wf.nSamplesPerSec;
247         TRACE("TIME_SMPTE=%02u:%02u:%02u:%02u\n",
248               lpTime->u.smpte.hour, lpTime->u.smpte.min,
249               lpTime->u.smpte.sec, lpTime->u.smpte.frame);
250         break;
251     default:
252         WARN("Format %d not supported, using TIME_BYTES !\n", lpTime->wType);
253         lpTime->wType = TIME_BYTES;
254         /* fall through */
255     case TIME_BYTES:
256         lpTime->u.cb = position;
257         TRACE("TIME_BYTES=%u\n", lpTime->u.cb);
258         break;
259     }
260     return MMSYSERR_NOERROR;
261 }
262
263
264 /*======================================================================*
265  *                  Low level WAVE implementation                       *
266  *======================================================================*/
267
268 #define SAMPLE_MAX_16BIT  32767.0f
269
270 /* Alsaplayer function that applies volume changes to a buffer */
271 /* (C) Andy Lo A Foe */
272 /* Length is in terms of 32 bit samples */
273 static void volume_effect32(void *buffer, int length, int left, int right)
274 {
275         short *data = buffer;
276         int i, v;
277     
278         if (right == -1) right = left;
279  
280         for(i = 0; i < length; i++) {
281                 v = (int) ((*(data) * left) / 100);
282                 *(data++) = (v>32767) ? 32767 : ((v<-32768) ? -32768 : v);
283                 v = (int) ((*(data) * right) / 100);
284                 *(data++) = (v>32767) ? 32767 : ((v<-32768) ? -32768 : v);
285         }
286 }
287
288 /* move 16 bit mono/stereo to 16 bit stereo */
289 static void sample_move_d16_d16(short *dst, short *src,
290                   unsigned long nsamples, int nChannels)
291 {
292   while(nsamples--)
293   {
294     *dst = *src;
295     dst++;
296
297     if(nChannels == 2) src++;
298
299     *dst = *src;
300     dst++;
301
302     src++;
303   }
304 }
305
306 /* convert from 16 bit to floating point */
307 /* allow for copying of stereo data with alternating left/right */
308 /* channels to a buffer that will hold a single channel stream */
309 /* nsamples is in terms of 16bit samples */
310 /* src_skip is in terms of 16bit samples */
311 static void sample_move_d16_s16 (sample_t *dst, short *src,
312                         unsigned long nsamples, unsigned long src_skip)
313 {
314   /* ALERT: signed sign-extension portability !!! */
315   while (nsamples--)
316   {
317     *dst = (*src) / SAMPLE_MAX_16BIT;
318     dst++;
319     src += src_skip;
320   }
321 }       
322
323 /* convert from floating point to 16 bit */
324 /* allow for copying of a buffer that will hold a single channel stream */
325 /* to stereo data with alternating left/right channels */
326 /* nsamples is in terms of float samples */
327 /* dst_skip is in terms of 16bit samples */
328 static void sample_move_s16_d16 (short *dst, sample_t *src,
329                         unsigned long nsamples, unsigned long dst_skip)
330 {
331   /* ALERT: signed sign-extension portability !!! */
332   while (nsamples--)
333   {
334       *dst = (*src) * SAMPLE_MAX_16BIT;
335 /*      TRACE("src=(%.8f,%p) dst=(%d,%p)\n",*src,src,*dst,dst); */
336       dst += dst_skip;
337       src++;
338   }
339 }       
340
341
342 /* fill dst buffer with nsamples worth of silence */
343 static void sample_silence_dS (sample_t *dst, unsigned long nsamples)
344 {
345   /* ALERT: signed sign-extension portability !!! */
346   while (nsamples--)
347   {
348     *dst = 0;
349     dst++;
350   }
351 }       
352
353 /******************************************************************
354  *    JACK_callback_wwo
355  */
356 /* everytime the jack server wants something from us it calls this 
357 function, so we either deliver it some sound to play or deliver it nothing 
358 to play */
359 static int JACK_callback_wwo (nframes_t nframes, void *arg)
360 {
361   sample_t* out_l;
362   sample_t* out_r;
363   WINE_WAVEOUT* wwo = arg;
364
365   TRACE("wDevID: %u, nframes %u state=%u\n", wwo->wDevID, nframes,wwo->state);
366
367   if(!wwo->client)
368     ERR("client is closed, this is weird...\n");
369
370   out_l = fp_jack_port_get_buffer(wwo->out_port_l, nframes);
371   out_r = fp_jack_port_get_buffer(wwo->out_port_r, nframes);
372
373   if(wwo->state == WINE_WS_PLAYING)
374   {
375     DWORD jackFramesAvailable = nframes;
376     DWORD outputFramesAvailable;
377     DWORD numFramesToWrite;
378
379     long written = 0;
380     char* buffer;
381
382 #if JACK_CLOSE_HACK
383     if(wwo->in_use == FALSE)
384     {
385       /* output silence if nothing is being outputted */
386       sample_silence_dS(out_l, nframes);
387       sample_silence_dS(out_r, nframes);
388
389       return 0;
390     }
391 #endif
392
393     TRACE("wwo.state == WINE_WS_PLAYING\n");
394
395     /* see if our sound_buffer is large enough to hold the number of frames jack requested */
396     /* Note: sound_buffer is always filled with 16-bit stereo data, even for mono mode */
397     if(wwo->buffer_size < (nframes * sizeof(short) * 2))
398     {
399       ERR("for some reason JACK_BufSize() didn't allocate enough memory\n");
400       ERR("allocated %ld bytes, need %d bytes\n", wwo->buffer_size, (nframes * sizeof(short) * 2));
401       return 0;
402     }
403
404     /* while we have jackFramesAvailable and a wave header to be played */
405     while(jackFramesAvailable && wwo->lpPlayPtr)
406     {
407       /* find the amount of audio to be played at this time */
408       outputFramesAvailable = (wwo->lpPlayPtr->dwBufferLength - wwo->dwPartialOffset) / wwo->format.wf.nBlockAlign;
409
410       numFramesToWrite = min(jackFramesAvailable, outputFramesAvailable);
411       TRACE("dwBufferLength=(%d) dwPartialOffset=(%d)\n",wwo->lpPlayPtr->dwBufferLength,wwo->dwPartialOffset);
412       TRACE("outputFramesAvailable == %d, jackFramesAvailable == %d\n", outputFramesAvailable, jackFramesAvailable);
413
414       buffer = wwo->lpPlayPtr->lpData + wwo->dwPartialOffset;
415
416       /* convert from mono to stereo if necessary */
417       /* otherwise just memcpy to the output buffer */
418
419       if(wwo->format.wf.nChannels == 1)
420       {
421         sample_move_d16_d16((short*)wwo->sound_buffer + ((nframes - jackFramesAvailable) * sizeof(short)),
422                             (short*)buffer, numFramesToWrite, wwo->format.wf.nChannels);
423       } else /* just copy the memory over */
424       {
425         memcpy(wwo->sound_buffer + ((nframes - jackFramesAvailable) * wwo->format.wf.nBlockAlign),
426                buffer, numFramesToWrite * wwo->format.wf.nBlockAlign);
427       }
428
429       /* advance to the next wave header if possible, or advance pointer */
430       /* inside of the current header if we haven't completed it */
431       if(numFramesToWrite == outputFramesAvailable)
432       {
433         wodHelper_PlayPtrNext(wwo);            /* we wrote the whole waveheader, skip to the next one*/
434       }
435       else
436       {
437         wwo->dwPartialOffset+=(numFramesToWrite * wwo->format.wf.nBlockAlign); /* else advance by the bytes we took in to write */
438       }
439
440       written+=(numFramesToWrite * wwo->format.wf.nBlockAlign); /* add on what we wrote */
441       jackFramesAvailable-=numFramesToWrite; /* take away what was written in terms of output bytes */
442     }
443
444     wwo->tickCountMS = GetTickCount();    /* record the current time */
445     wwo->dwWrittenTotal+=written; /* update states on wave device */
446     wwo->dwPlayedTotal+=wwo->bytesInJack; /* we must have finished with the last bytes or we wouldn't be back inside of this callback again... */
447     wwo->bytesInJack = written; /* record the bytes inside of jack */
448
449     /* Now that we have finished filling the buffer either until it is full or until */
450     /* we have run out of application sound data to process, apply volume and output */
451     /* the audio to the jack server */
452
453     /* apply volume to the buffer */
454     volume_effect32(wwo->sound_buffer, (nframes - jackFramesAvailable), wwo->volume_left, wwo->volume_right);
455
456     /* convert from stereo 16 bit to single channel 32 bit float */
457     /* for each jack server channel */
458     /* NOTE: we skip over two sample since we want to only get either the left or right channel */
459     sample_move_d16_s16(out_l, (short*)wwo->sound_buffer,     (nframes - jackFramesAvailable), 2);
460     sample_move_d16_s16(out_r, (short*)wwo->sound_buffer + 1, (nframes - jackFramesAvailable), 2);
461
462     /* see if we still have jackBytesLeft here, if we do that means that we
463     ran out of wave data to play and had a buffer underrun, fill in
464     the rest of the space with zero bytes */
465     if(jackFramesAvailable)
466     {
467       ERR("buffer underrun of %d frames\n", jackFramesAvailable);
468       sample_silence_dS(out_l + (nframes - jackFramesAvailable), jackFramesAvailable);
469       sample_silence_dS(out_r + (nframes - jackFramesAvailable), jackFramesAvailable);
470     }
471   }
472   else if(wwo->state == WINE_WS_PAUSED || 
473     wwo->state == WINE_WS_STOPPED ||
474     wwo->state == WINE_WS_CLOSED)
475   {
476       /* output silence if nothing is being outputted */
477       sample_silence_dS(out_l, nframes);
478       sample_silence_dS(out_r, nframes);
479   }
480
481   /* notify the client of completed wave headers */
482   EnterCriticalSection(&wwo->access_crst);
483   wodHelper_NotifyCompletions(wwo, FALSE);
484   LeaveCriticalSection(&wwo->access_crst);
485
486   return 0;
487 }
488
489 /******************************************************************
490  *              JACK_bufsize_wwo
491  *
492  *              Called whenever the jack server changes the max number
493  *              of frames passed to JACK_callback
494  */
495 static int JACK_bufsize_wwo (nframes_t nframes, void *arg)
496 {
497   WINE_WAVEOUT* wwo = arg;
498   DWORD buffer_required;
499   TRACE("wDevID=%d\n",wwo->wDevID);
500   TRACE("the maximum buffer size is now %u frames\n", nframes);
501
502   /* make sure the callback routine has adequate memory */
503     /* see if our buffer is large enough for the data we are writing */
504     /* ie. Buffer_size < (bytes we already wrote + bytes we are going to write in this loop) */
505   EnterCriticalSection(&wwo->access_crst);
506
507   /* wwo->sound_buffer is always filled with 16-bit stereo data, even for mono streams */
508   buffer_required = nframes * sizeof(short) * 2;
509   TRACE("wwo->buffer_size (%ld) buffer_required (%d).\n", wwo->buffer_size,buffer_required);
510   if(wwo->buffer_size < buffer_required)
511   {
512     TRACE("expanding buffer from wwo->buffer_size == %ld, to %d\n",
513       wwo->buffer_size, buffer_required);
514     TRACE("GetProcessHeap() == %p\n", GetProcessHeap());
515     wwo->buffer_size = buffer_required;
516
517     if (wwo->sound_buffer)
518       wwo->sound_buffer = HeapReAlloc(GetProcessHeap(), 0, wwo->sound_buffer, wwo->buffer_size);
519     else
520       wwo->sound_buffer = HeapAlloc(GetProcessHeap(), 0, wwo->buffer_size);
521
522     /* if we don't have a buffer then error out */
523     if(!wwo->sound_buffer)
524     {
525         ERR("error allocating sound_buffer memory\n");
526         LeaveCriticalSection(&wwo->access_crst);
527         return 0;
528     }
529   }
530
531   LeaveCriticalSection(&wwo->access_crst);
532
533   TRACE("ending\n");
534
535   return 0;
536 }
537 /******************************************************************
538  *              JACK_bufsize_wwi
539  *
540  *              Called whenever the jack server changes the max number
541  *              of frames passed to JACK_callback
542  */
543 static int JACK_bufsize_wwi (nframes_t nframes, void *arg)
544 {
545   TRACE("the maximum buffer size is now %u frames\n", nframes);
546   return 0;
547 }
548
549 /******************************************************************
550  *              JACK_srate
551  */
552 static int JACK_srate (nframes_t nframes, void *arg)
553 {
554   TRACE("the sample rate is now %u/sec\n", nframes);
555   return 0;
556 }
557
558
559 /******************************************************************
560  *              JACK_shutdown_wwo
561  */
562 /* if this is called then jack shut down... handle this appropriately */
563 static void JACK_shutdown_wwo(void* arg)
564 {
565   WINE_WAVEOUT* wwo = arg;
566
567   wwo->client = 0; /* reset client */
568
569   TRACE("trying to reconnect after sleeping for a short while...\n");
570   
571   /* lets see if we can't reestablish the connection */
572   Sleep(750); /* pause for a short period of time */
573   if(!JACK_OpenWaveOutDevice(wwo))
574   {
575     ERR("unable to reconnect with jack...\n");
576   }
577 }
578
579 /******************************************************************
580  *              JACK_shutdown_wwi
581  */
582 /* if this is called then jack shut down... handle this appropriately */
583 static void JACK_shutdown_wwi(void* arg)
584 {
585   WINE_WAVEIN* wwi = arg;
586
587   wwi->client = 0; /* reset client */
588
589   TRACE("trying to reconnect after sleeping for a short while...\n");
590   
591   /* lets see if we can't reestablish the connection */
592   Sleep(750); /* pause for a short period of time */
593   if(!JACK_OpenWaveInDevice(wwi,wwi->format.wf.nChannels))
594   {
595     ERR("unable to reconnect with jack...\n");
596   }
597 }
598
599
600 /******************************************************************
601  *              JACK_OpenWaveOutDevice
602  */
603 static int JACK_OpenWaveOutDevice(WINE_WAVEOUT* wwo)
604 {
605   const char** ports;
606   int i;
607   char client_name[64];
608   jack_port_t* out_port_l;
609   jack_port_t* out_port_r;
610   jack_client_t* client;
611   int failed = 0;
612
613   TRACE("creating jack client and setting up callbacks\n");
614
615 #if JACK_CLOSE_HACK
616   /* see if this device is already open */
617         if(wwo->client)
618         {
619           /* if this device is already in use then it is bad for us to be in here */
620           if(wwo->in_use)
621             return 0;
622
623           TRACE("using existing client\n");
624           wwo->in_use = TRUE;
625           return 1;
626         }
627 #endif
628
629         /* zero out the buffer pointer and the size of the buffer */
630         wwo->sound_buffer = 0;
631         wwo->buffer_size = 0;
632
633         /* try to become a client of the JACK server */
634         snprintf(client_name, sizeof(client_name), "wine_jack_out_%d", wwo->wDevID);
635         TRACE("client name '%s'\n", client_name);
636         if ((client = fp_jack_client_new (client_name)) == 0)
637         {
638                 /* jack has problems with shutting down clients, so lets */
639                 /* wait a short while and try once more before we give up */
640                 Sleep(250);
641                 if ((client = fp_jack_client_new (client_name)) == 0)
642                 {
643                   ERR("jack server not running?\n");
644                   return 0;
645                 }
646         }
647                         
648         /* tell the JACK server to call `JACK_callback_wwo()' whenever
649            there is work to be done. */
650         fp_jack_set_process_callback (client, JACK_callback_wwo, wwo);
651         
652         /* tell the JACK server to call `JACK_bufsize_wwo()' whenever   
653            the maximum number of frames that will be passed
654            to `JACK_Callback()' changes */
655         fp_jack_set_buffer_size_callback (client, JACK_bufsize_wwo, wwo);
656
657         /* tell the JACK server to call `srate()' whenever
658            the sample rate of the system changes. */
659         fp_jack_set_sample_rate_callback (client, JACK_srate, wwo);
660
661         /* tell the JACK server to call `jack_shutdown()' if
662            it ever shuts down, either entirely, or if it
663            just decides to stop calling us. */
664         fp_jack_on_shutdown (client, JACK_shutdown_wwo, wwo);
665         
666         /* display the current sample rate. once the client is activated
667            (see below), you should rely on your own sample rate
668            callback (see above) for this value. */
669         wwo->sample_rate = fp_jack_get_sample_rate(client);
670         TRACE("engine sample rate: %lu\n", wwo->sample_rate);
671           
672         /* create the left and right channel output ports */
673         /* jack's ports are all mono so for stereo you need two */
674         out_port_l = fp_jack_port_register (client, "out_l",
675                          JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
676
677         out_port_r = fp_jack_port_register (client, "out_r",
678                          JACK_DEFAULT_AUDIO_TYPE, JackPortIsOutput, 0);
679
680         TRACE("Created ports. (%p) (%p)\n",out_port_l, out_port_r);
681
682         /* save away important values to the WINE_WAVEOUT struct */
683         wwo->client = client;
684         wwo->out_port_l = out_port_l;
685         wwo->out_port_r = out_port_r;
686
687 #if JACK_CLOSE_HACK
688         wwo->in_use = TRUE; /* mark this device as in use since it now is ;-) */
689 #endif
690
691         /* set initial buffer size */
692         JACK_bufsize_wwo (fp_jack_get_buffer_size(client),wwo);
693
694         /* tell the JACK server that we are ready to roll */
695         if (fp_jack_activate (client))
696         {
697           ERR( "cannot activate client\n");
698           return 0;
699         }
700
701         TRACE("jack activate.\n");
702         /* figure out what the ports that we want to output on are */
703         /* NOTE: we do this instead of using stuff like "alsa_pcm:playback_X" because */
704         /*   this way works if names are changed */
705         ports = fp_jack_get_ports(client, NULL, NULL, JackPortIsPhysical|JackPortIsInput);
706
707         /* display a trace of the output ports we found */
708         for(i = 0; ports[i]; i++)
709         {
710           TRACE("ports[%d] = '%s'\n", i, ports[i]);
711         }
712
713         if(!ports)
714         {
715           ERR("jack_get_ports() failed to find 'JackPortIsPhysical|JackPortIsInput'\n");
716         }
717
718         /* connect the ports. Note: you can't do this before
719            the client is activated (this may change in the future).
720         */ 
721         /* we want to connect to two ports so we have stereo output ;-) */
722
723         if(fp_jack_connect(client, fp_jack_port_name(out_port_l), ports[0]))
724         {
725           ERR ("cannot connect to output port %d('%s')\n", 0, ports[0]);
726           failed = 1;
727         }
728
729         if(fp_jack_connect(client, fp_jack_port_name(out_port_r), ports[1]))
730         {
731           ERR ("cannot connect to output port %d('%s')\n", 1, ports[1]);
732           failed = 1;
733         }
734
735         free(ports); /* free the returned array of ports */
736
737         /* if something failed we need to shut the client down and return 0 */
738         if(failed)
739         {
740 #if JACK_CLOSE_HACK
741           JACK_CloseWaveOutDevice(wwo, TRUE);
742 #else
743           JACK_CloseWaveOutDevice(wwo);
744 #endif
745           return 0;
746         }
747
748         return 1; /* return success */
749 }
750
751 /******************************************************************
752  *              JACK_CloseWaveOutDevice
753  *
754  *      Close the connection to the server cleanly.
755  *  If close_client is TRUE we close the client for this device instead of
756  *    just marking the device as in_use(JACK_CLOSE_HACK only)
757  */
758 #if JACK_CLOSE_HACK
759 static void     JACK_CloseWaveOutDevice(WINE_WAVEOUT* wwo, BOOL close_client)
760 #else
761 static void     JACK_CloseWaveOutDevice(WINE_WAVEOUT* wwo)
762 #endif
763 {
764 #if JACK_CLOSE_HACK
765   TRACE("wDevID: %d, close_client (wwo): %d\n", wwo->wDevID, close_client);
766 #else
767   TRACE("wDevID: %d\n", wwo->wDevID);
768 #endif
769
770 #if JACK_CLOSE_HACK
771   if(close_client)
772   {
773 #endif
774     fp_jack_deactivate(wwo->client); /* supposed to help the jack_client_close() to succeed */
775     fp_jack_client_close (wwo->client);
776
777     EnterCriticalSection(&wwo->access_crst);
778     wwo->client = 0; /* reset client */
779     HeapFree(GetProcessHeap(), 0, wwo->sound_buffer); /* free buffer memory */
780     wwo->sound_buffer = 0;
781     wwo->buffer_size = 0; /* zero out size of the buffer */
782     LeaveCriticalSection(&wwo->access_crst);
783 #if JACK_CLOSE_HACK
784   } else
785   {
786     EnterCriticalSection(&wwo->access_crst);
787     TRACE("setting in_use to FALSE\n");
788     wwo->in_use = FALSE;
789     LeaveCriticalSection(&wwo->access_crst);
790   }
791 #endif
792 }
793
794 /******************************************************************
795  *              JACK_CloseWaveInDevice
796  *
797  *      Close the connection to the server cleanly.
798  *  If close_client is TRUE we close the client for this device instead of
799  *    just marking the device as in_use(JACK_CLOSE_HACK only)
800  */
801 #if JACK_CLOSE_HACK
802 static void     JACK_CloseWaveInDevice(WINE_WAVEIN* wwi, BOOL close_client)
803 #else
804 static void     JACK_CloseWaveInDevice(WINE_WAVEIN* wwi)
805 #endif
806 {
807 #if JACK_CLOSE_HACK
808   TRACE("wDevID: %d, close_client (wwi): %d\n", wwi->wDevID, close_client);
809 #else
810   TRACE("wDevID: %d\n", wwi->wDevID);
811 #endif
812
813 #if JACK_CLOSE_HACK
814   if(close_client)
815   {
816 #endif
817     fp_jack_deactivate(wwi->client); /* supposed to help the jack_client_close() to succeed */
818     fp_jack_client_close (wwi->client);
819
820     EnterCriticalSection(&wwi->access_crst);
821     wwi->client = 0; /* reset client */
822     HeapFree(GetProcessHeap(), 0, wwi->sound_buffer); /* free buffer memory */
823     wwi->sound_buffer = 0;
824     wwi->buffer_size = 0; /* zero out size of the buffer */
825     LeaveCriticalSection(&wwi->access_crst);
826 #if JACK_CLOSE_HACK
827   } else
828   {
829     EnterCriticalSection(&wwi->access_crst);
830     TRACE("setting in_use to FALSE\n");
831     wwi->in_use = FALSE;
832     LeaveCriticalSection(&wwi->access_crst);
833   }
834 #endif
835 }
836
837 /******************************************************************
838  *              JACK_WaveRelease
839  *
840  *
841  */
842 LONG    JACK_WaveRelease(void)
843
844   int iDevice;
845
846   TRACE("closing all open waveout devices\n");
847
848   /* close all open output devices */
849   for(iDevice = 0; iDevice < MAX_WAVEOUTDRV; iDevice++)
850   {
851     TRACE("iDevice == %d\n", iDevice);
852     if(WOutDev[iDevice].client)
853     {
854 #if JACK_CLOSE_HACK
855       JACK_CloseWaveOutDevice(&WOutDev[iDevice], TRUE); /* close the device, FORCE the client to close */
856 #else
857       JACK_CloseWaveOutDevice(&WOutDev[iDevice]); /* close the device, FORCE the client to close */
858 #endif
859       DeleteCriticalSection(&(WOutDev[iDevice].access_crst)); /* delete the critical section */
860     }
861   }
862
863   TRACE("closing all open wavein devices\n");
864
865   /* close all open input devices */
866   for(iDevice = 0; iDevice < MAX_WAVEINDRV; iDevice++)
867   {
868     TRACE("iDevice == %d\n", iDevice);
869     if(WInDev[iDevice].client)
870     {
871 #if JACK_CLOSE_HACK
872       JACK_CloseWaveInDevice(&WInDev[iDevice], TRUE); /* close the device, FORCE the client to close */
873 #else
874       JACK_CloseWaveInDevice(&WInDev[iDevice]); /* close the device, FORCE the client to close */
875 #endif
876       DeleteCriticalSection(&(WInDev[iDevice].access_crst)); /* delete the critical section */
877     }
878   }
879
880   TRACE("returning 1\n");
881
882   return 1;
883 }
884
885 /******************************************************************
886  *              JACK_WaveInit
887  *
888  * Initialize internal structures from JACK server info
889  */
890 LONG JACK_WaveInit(void)
891 {
892     int i;
893     CHAR szPname[MAXPNAMELEN];
894
895     TRACE("called\n");
896
897     /* setup function pointers */
898 #define LOAD_FUNCPTR(f) if((fp_##f = wine_dlsym(jackhandle, #f, NULL, 0)) == NULL) goto sym_not_found;    
899     LOAD_FUNCPTR(jack_activate);
900     LOAD_FUNCPTR(jack_connect);
901     LOAD_FUNCPTR(jack_client_new);
902     LOAD_FUNCPTR(jack_client_close);
903     LOAD_FUNCPTR(jack_deactivate);
904     LOAD_FUNCPTR(jack_set_process_callback);
905     LOAD_FUNCPTR(jack_set_buffer_size_callback);
906     LOAD_FUNCPTR(jack_set_sample_rate_callback);
907     LOAD_FUNCPTR(jack_on_shutdown);
908     LOAD_FUNCPTR(jack_get_sample_rate);
909     LOAD_FUNCPTR(jack_port_register);
910     LOAD_FUNCPTR(jack_port_get_buffer);
911     LOAD_FUNCPTR(jack_get_ports);
912     LOAD_FUNCPTR(jack_port_name);
913     LOAD_FUNCPTR(jack_get_buffer_size);
914 #undef LOAD_FUNCPTR
915
916     /* start with output device */
917
918     for (i = 0; i < MAX_WAVEOUTDRV; ++i)
919     {
920       WOutDev[i].client = 0; /* initialize the client to 0 */
921
922 #if JACK_CLOSE_HACK
923       WOutDev[i].in_use = FALSE;
924       WInDev[i].in_use  = FALSE;
925 #endif
926
927       memset(&WOutDev[i].caps, 0, sizeof(WOutDev[i].caps));
928
929       WOutDev[i].caps.wMid = 0x00FF;    /* Manufac ID */
930       WOutDev[i].caps.wPid = 0x0001;    /* Product ID */
931       snprintf(szPname, sizeof(szPname), "JACK WaveOut %d", i);
932       MultiByteToWideChar(CP_ACP, 0, szPname, -1, WOutDev[i].caps.szPname, sizeof(WOutDev[i].caps.szPname)/sizeof(WCHAR));
933       snprintf(WOutDev[i].interface_name, sizeof(WOutDev[i].interface_name), "winejack: %d", i);
934
935       WOutDev[i].caps.vDriverVersion = 0x0100;
936       WOutDev[i].caps.dwFormats = 0x00000000;
937       WOutDev[i].caps.dwSupport = WAVECAPS_VOLUME;
938     
939       WOutDev[i].caps.wChannels = 2;
940       WOutDev[i].caps.dwSupport |= WAVECAPS_LRVOLUME;
941
942 /* NOTE: we don't support any 8 bit modes so note that */
943 /*      WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M08;
944       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S08; */
945       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S16;
946       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M16;
947 /*      WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M08;
948       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S08; */
949       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M16;
950       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S16;
951 /*      WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M08;
952       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S08;*/
953       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M16;
954       WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S16;
955     }
956
957     /* then do input device */
958     for (i = 0; i < MAX_WAVEINDRV; ++i)
959     {
960         /* TODO: we should initialize read stuff here */
961         memset(&WInDev[i].caps, 0, sizeof(WInDev[i].caps));
962
963         WInDev[i].caps.wMid = 0x00FF;
964         WInDev[i].caps.wPid = 0x0001;
965         snprintf(szPname, sizeof(szPname), "JACK WaveIn %d", i);
966         MultiByteToWideChar(CP_ACP, 0, szPname, -1, WInDev[i].caps.szPname, sizeof(WInDev[i].caps.szPname)/sizeof(WCHAR));
967         snprintf(WInDev[i].interface_name, sizeof(WInDev[i].interface_name), "winejack: %d", i);
968
969         WInDev[i].caps.vDriverVersion = 0x0100;
970
971         WInDev[i].caps.wChannels = 0x2;
972         /* NOTE: we don't support any 8 bit modes so note that */
973 /*      WInDev[i].caps.dwFormats |= WAVE_FORMAT_4M08;
974         WInDev[i].caps.dwFormats |= WAVE_FORMAT_4S08; */
975         WInDev[i].caps.dwFormats |= WAVE_FORMAT_4S16;
976         WInDev[i].caps.dwFormats |= WAVE_FORMAT_4M16;
977 /*      WInDev[i].caps.dwFormats |= WAVE_FORMAT_2M08;
978         WInDev[i].caps.dwFormats |= WAVE_FORMAT_2S08; */
979         WInDev[i].caps.dwFormats |= WAVE_FORMAT_2M16;
980         WInDev[i].caps.dwFormats |= WAVE_FORMAT_2S16;
981 /*      WInDev[i].caps.dwFormats |= WAVE_FORMAT_1M08;
982         WInDev[i].caps.dwFormats |= WAVE_FORMAT_1S08;*/
983         WInDev[i].caps.dwFormats |= WAVE_FORMAT_1M16;
984         WInDev[i].caps.dwFormats |= WAVE_FORMAT_1S16;
985         WInDev[i].caps.wReserved1 = 0;
986     }
987     
988     return 1;           /* return success */
989
990 /* error path for function pointer loading errors */
991 sym_not_found:
992     WINE_MESSAGE(
993       "Wine cannot find certain functions that it needs inside the jack"
994       "library.  To enable Wine to use the jack audio server please "
995       "install libjack\n");
996     wine_dlclose(jackhandle, NULL, 0);
997     jackhandle = NULL;
998     return FALSE;
999 }
1000
1001 /*======================================================================*
1002  *                  Low level WAVE OUT implementation                   *
1003  *======================================================================*/
1004
1005 /**************************************************************************
1006  *                      wodNotifyClient                 [internal]
1007  */
1008 static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD_PTR dwParam1,
1009                              DWORD_PTR dwParam2)
1010 {
1011     TRACE("wMsg = %04X dwParm1 = %08lX dwParam2 = %08lX\n", wMsg, dwParam1, dwParam2);
1012
1013     switch (wMsg) {
1014     case WOM_OPEN:
1015     case WOM_CLOSE:
1016     case WOM_DONE:
1017       if (wwo->wFlags != DCB_NULL &&
1018         !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags,
1019           (HDRVR)wwo->waveDesc.hWave, wMsg, wwo->waveDesc.dwInstance,
1020           dwParam1, dwParam2))
1021       {
1022         WARN("can't notify client !\n");
1023         return MMSYSERR_ERROR;
1024       }
1025     break;
1026     default:
1027       FIXME("Unknown callback message %u\n", wMsg);
1028         return MMSYSERR_INVALPARAM;
1029     }
1030     return MMSYSERR_NOERROR;
1031 }
1032
1033 /**************************************************************************
1034  *                              wodHelper_BeginWaveHdr          [internal]
1035  *
1036  * Makes the specified lpWaveHdr the currently playing wave header.
1037  * If the specified wave header is a begin loop and we're not already in
1038  * a loop, setup the loop.
1039  */
1040 static void wodHelper_BeginWaveHdr(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
1041 {
1042     EnterCriticalSection(&wwo->access_crst);
1043
1044     wwo->lpPlayPtr = lpWaveHdr;
1045
1046     if (!lpWaveHdr)
1047     {
1048        LeaveCriticalSection(&wwo->access_crst);
1049        return;
1050     }
1051
1052     if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)
1053     {
1054       if (wwo->lpLoopPtr)
1055       {
1056         WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
1057         TRACE("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
1058       } else
1059       {
1060         TRACE("Starting loop (%dx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
1061         wwo->lpLoopPtr = lpWaveHdr;
1062         /* Windows does not touch WAVEHDR.dwLoops,
1063          * so we need to make an internal copy */
1064         wwo->dwLoops = lpWaveHdr->dwLoops;
1065       }
1066     }
1067     wwo->dwPartialOffset = 0;
1068
1069     LeaveCriticalSection(&wwo->access_crst);
1070 }
1071
1072
1073 /**************************************************************************
1074  *                              wodHelper_PlayPtrNext           [internal]
1075  *
1076  * Advance the play pointer to the next waveheader, looping if required.
1077  */
1078 static LPWAVEHDR wodHelper_PlayPtrNext(WINE_WAVEOUT* wwo)
1079 {
1080   LPWAVEHDR lpWaveHdr;
1081
1082   EnterCriticalSection(&wwo->access_crst);
1083
1084   lpWaveHdr = wwo->lpPlayPtr;
1085
1086   wwo->dwPartialOffset = 0;
1087   if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr)
1088   {
1089     /* We're at the end of a loop, loop if required */
1090     if (--wwo->dwLoops > 0)
1091     {
1092       wwo->lpPlayPtr = wwo->lpLoopPtr;
1093     } else
1094     {
1095       /* Handle overlapping loops correctly */
1096       if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
1097         FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
1098         /* shall we consider the END flag for the closing loop or for
1099          * the opening one or for both ???
1100          * code assumes for closing loop only
1101          */
1102       } else
1103       {
1104         lpWaveHdr = lpWaveHdr->lpNext;
1105       }
1106       wwo->lpLoopPtr = NULL;
1107       wodHelper_BeginWaveHdr(wwo, lpWaveHdr);
1108     }
1109   } else
1110   {
1111      /* We're not in a loop.  Advance to the next wave header */
1112     TRACE("not inside of a loop, advancing to next wave header\n");
1113     wodHelper_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
1114   }
1115
1116   LeaveCriticalSection(&wwo->access_crst);
1117
1118   return lpWaveHdr;
1119 }
1120
1121 /* if force is TRUE then notify the client that all the headers were completed */
1122 static DWORD wodHelper_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
1123 {
1124   LPWAVEHDR             lpWaveHdr;
1125   DWORD retval;
1126
1127   TRACE("called\n");
1128
1129   EnterCriticalSection(&wwo->access_crst);
1130
1131   /* Start from lpQueuePtr and keep notifying until:
1132    * - we hit an unwritten wavehdr
1133    * - we hit the beginning of a running loop
1134    * - we hit a wavehdr which hasn't finished playing
1135    */
1136   while ((lpWaveHdr = wwo->lpQueuePtr) &&
1137            (force || 
1138             (lpWaveHdr != wwo->lpPlayPtr &&
1139              lpWaveHdr != wwo->lpLoopPtr)))
1140   {
1141     wwo->lpQueuePtr = lpWaveHdr->lpNext;
1142
1143     lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1144     lpWaveHdr->dwFlags |= WHDR_DONE;
1145     TRACE("notifying client: lpWaveHdr=(%p) lpPlayPtr=(%p) dwFlags=(%d)\n",
1146           lpWaveHdr, wwo->lpPlayPtr, lpWaveHdr->dwFlags);
1147
1148     wodNotifyClient(wwo, WOM_DONE, (DWORD_PTR)lpWaveHdr, 0);
1149   }
1150   TRACE("Not notifying client: lpWaveHdr=(%p) lpPlayPtr=(%p) lpLoopPtr=(%p)\n",
1151         lpWaveHdr, wwo->lpPlayPtr, wwo->lpLoopPtr);
1152   retval = (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr != 
1153               wwo->lpLoopPtr) ? 0 : INFINITE;
1154
1155   LeaveCriticalSection(&wwo->access_crst);
1156
1157   return retval;
1158 }
1159
1160 /**************************************************************************
1161  *                              wodHelper_Reset                 [internal]
1162  *
1163  * Resets current output stream.
1164  */
1165 static  void  wodHelper_Reset(WINE_WAVEOUT* wwo, BOOL reset)
1166 {
1167     EnterCriticalSection(&wwo->access_crst);
1168  
1169     /* updates current notify list */
1170     wodHelper_NotifyCompletions(wwo, FALSE);
1171
1172     if (reset)
1173     {
1174         /* remove all wave headers and notify client that all headers were completed */
1175         wodHelper_NotifyCompletions(wwo, TRUE);
1176
1177         wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
1178         wwo->state = WINE_WS_STOPPED;
1179         wwo->dwPlayedTotal = wwo->dwWrittenTotal = wwo->bytesInJack = 0;
1180
1181         wwo->dwPartialOffset = 0;        /* Clear partial wavehdr */
1182     } else
1183     {
1184         if (wwo->lpLoopPtr)
1185         {
1186             /* complicated case, not handled yet (could imply modifying the loop counter) */
1187             FIXME("Pausing while in loop isn't correctly handled yet, expect strange results\n");
1188             wwo->lpPlayPtr = wwo->lpLoopPtr;
1189             wwo->dwPartialOffset = 0;
1190             wwo->dwWrittenTotal = wwo->dwPlayedTotal; /* this is wrong !!! */
1191         } else
1192         {
1193             LPWAVEHDR   ptr;
1194             DWORD       sz = wwo->dwPartialOffset;
1195
1196             /* reset all the data as if we had written only up to lpPlayedTotal bytes */
1197             /* compute the max size playable from lpQueuePtr */
1198             for (ptr = wwo->lpQueuePtr; ptr != wwo->lpPlayPtr; ptr = ptr->lpNext)
1199             {
1200                 sz += ptr->dwBufferLength;
1201             }
1202
1203             /* because the reset lpPlayPtr will be lpQueuePtr */
1204             if (wwo->dwWrittenTotal > wwo->dwPlayedTotal + sz) ERR("doh\n");
1205             wwo->dwPartialOffset = sz - (wwo->dwWrittenTotal - wwo->dwPlayedTotal);
1206             wwo->dwWrittenTotal = wwo->dwPlayedTotal;
1207             wwo->lpPlayPtr = wwo->lpQueuePtr;
1208         }
1209
1210         wwo->state = WINE_WS_PAUSED;
1211     }
1212  
1213     LeaveCriticalSection(&wwo->access_crst);
1214 }
1215
1216 /**************************************************************************
1217  *                      wodGetDevCaps                           [internal]
1218  */
1219 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSW lpCaps, DWORD dwSize)
1220 {
1221     TRACE("(%u, %p, %u);\n", wDevID, lpCaps, dwSize);
1222     
1223     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1224     
1225     if (wDevID >= MAX_WAVEOUTDRV)
1226     {
1227       TRACE("MAX_WAVOUTDRV reached !\n");
1228       return MMSYSERR_BADDEVICEID;
1229     }
1230
1231     TRACE("dwSupport=(0x%x), dwFormats=(0x%x)\n", WOutDev[wDevID].caps.dwSupport, WOutDev[wDevID].caps.dwFormats);
1232     memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
1233     return MMSYSERR_NOERROR;
1234 }
1235
1236 /**************************************************************************
1237  *                              wodOpen                         [internal]
1238  *
1239  * NOTE: doesn't it seem like there is a race condition if you try to open 
1240  * the same device twice?
1241  */
1242 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1243 {
1244     WINE_WAVEOUT*       wwo;
1245     DWORD retval;
1246
1247     TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
1248     if (lpDesc == NULL)
1249     {
1250       WARN("Invalid Parameter !\n");
1251       return MMSYSERR_INVALPARAM;
1252     }
1253     if (wDevID >= MAX_WAVEOUTDRV) {
1254       TRACE("MAX_WAVOUTDRV reached !\n");
1255       return MMSYSERR_BADDEVICEID;
1256     }
1257
1258 #if JACK_CLOSE_HACK
1259     if(WOutDev[wDevID].client && WOutDev[wDevID].in_use)
1260 #else
1261     if(WOutDev[wDevID].client)
1262 #endif
1263     {
1264       TRACE("device %d already allocated\n", wDevID);
1265       return MMSYSERR_ALLOCATED;
1266     }
1267
1268     /* Only the PCM format is supported so far...
1269      * Also we only support 16 bit mode.
1270      */
1271     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
1272       lpDesc->lpFormat->nChannels == 0 ||
1273       lpDesc->lpFormat->nSamplesPerSec == 0 ||
1274       lpDesc->lpFormat->wBitsPerSample != 16)
1275     {
1276       WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d wBitsPerSample=%d !\n",
1277        lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1278        lpDesc->lpFormat->nSamplesPerSec, lpDesc->lpFormat->wBitsPerSample);
1279       return WAVERR_BADFORMAT;
1280     }
1281
1282     if (dwFlags & WAVE_FORMAT_QUERY)
1283     {
1284       TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1285        lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1286        lpDesc->lpFormat->nSamplesPerSec);
1287       return MMSYSERR_NOERROR;
1288     }
1289
1290     wwo = &WOutDev[wDevID];
1291     wwo->wDevID = wDevID;
1292
1293     /* Set things up before we call JACK_OpenWaveOutDevice because */
1294     /* we will start getting callbacks before JACK_OpenWaveOutDevice */
1295     /* even returns and we want to be initialized before then */
1296     wwo->state = WINE_WS_STOPPED; /* start in a stopped state */
1297     wwo->dwPlayedTotal = 0; /* zero out these totals */
1298     wwo->dwWrittenTotal = 0;
1299     wwo->bytesInJack = 0;
1300     wwo->tickCountMS = 0;
1301
1302     /* Initialize volume to full level */
1303     wwo->volume_left = 100;
1304     wwo->volume_right = 100;
1305
1306     InitializeCriticalSection(&wwo->access_crst); /* initialize the critical section */
1307     EnterCriticalSection(&wwo->access_crst);
1308
1309     dwFlags &= ~WAVE_DIRECTSOUND;  /* direct sound not supported, ignore the flag */
1310
1311     wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1312
1313     wwo->waveDesc = *lpDesc;
1314     memcpy(&wwo->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
1315
1316     /* open up jack ports for this device */
1317     if (!JACK_OpenWaveOutDevice(&WOutDev[wDevID]))
1318     {
1319       ERR("JACK_OpenWaveOutDevice(%d) failed\n", wDevID);
1320       LeaveCriticalSection(&wwo->access_crst);
1321       DeleteCriticalSection(&wwo->access_crst); /* delete the critical section so we can initialize it again from wodOpen() */
1322       return MMSYSERR_ERROR;            /* return unspecified error */
1323     }
1324
1325     LeaveCriticalSection(&wwo->access_crst);
1326
1327     /* display the current wave format */
1328     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
1329     wwo->format.wBitsPerSample, wwo->format.wf.nAvgBytesPerSec,
1330     wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
1331     wwo->format.wf.nBlockAlign);
1332
1333     /* make sure that we have the same sample rate in our audio stream */
1334     /* as we do in the jack server */
1335     if(wwo->format.wf.nSamplesPerSec != wwo->sample_rate)
1336     {
1337       TRACE("error: jack server sample rate is '%ld', wave sample rate is '%d'\n",
1338          wwo->sample_rate, wwo->format.wf.nSamplesPerSec);
1339
1340 #if JACK_CLOSE_HACK
1341       JACK_CloseWaveOutDevice(wwo, FALSE); /* close this device, don't force the client to close */
1342 #else
1343       JACK_CloseWaveOutDevice(wwo); /* close this device */
1344 #endif
1345       DeleteCriticalSection(&wwo->access_crst); /* delete the critical section so we can initialize it again from wodOpen() */
1346       return WAVERR_BADFORMAT;
1347     }
1348
1349     /* check for an invalid number of bits per sample */
1350     if (wwo->format.wBitsPerSample == 0)
1351     {
1352       WARN("Resetting zeroed wBitsPerSample\n");
1353       wwo->format.wBitsPerSample = 8 *
1354       (wwo->format.wf.nAvgBytesPerSec /
1355        wwo->format.wf.nSamplesPerSec) /
1356        wwo->format.wf.nChannels;
1357     }
1358
1359     EnterCriticalSection(&wwo->access_crst);
1360     retval = wodNotifyClient(wwo, WOM_OPEN, 0, 0);
1361     LeaveCriticalSection(&wwo->access_crst);
1362
1363     return retval;
1364 }
1365
1366 /**************************************************************************
1367  *                              wodClose                        [internal]
1368  */
1369 static DWORD wodClose(WORD wDevID)
1370 {
1371     DWORD               ret = MMSYSERR_NOERROR;
1372     WINE_WAVEOUT*       wwo;
1373
1374     TRACE("(%u);\n", wDevID);
1375
1376     if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1377     {
1378       WARN("bad device ID !\n");
1379       return MMSYSERR_BADDEVICEID;
1380     }
1381     
1382     wwo = &WOutDev[wDevID];
1383     if (wwo->lpQueuePtr)
1384     {
1385       WARN("buffers still playing !\n");
1386       ret = WAVERR_STILLPLAYING;
1387     } else
1388     {
1389       /* sanity check: this should not happen since the device must have been reset before */
1390       if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
1391
1392       wwo->state = WINE_WS_CLOSED; /* mark the device as closed */
1393
1394 #if JACK_CLOSE_HACK
1395       JACK_CloseWaveOutDevice(wwo, FALSE); /* close the jack device, DO NOT force the client to close */
1396 #else
1397       JACK_CloseWaveOutDevice(wwo); /* close the jack device */
1398 #endif
1399       DeleteCriticalSection(&wwo->access_crst); /* delete the critical section so we can initialize it again from wodOpen() */
1400
1401       ret = wodNotifyClient(wwo, WOM_CLOSE, 0, 0);
1402     }
1403
1404     return ret;
1405 }
1406
1407
1408 /**************************************************************************
1409  *                              wodWrite                        [internal]
1410  * 
1411  */
1412 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1413 {
1414     LPWAVEHDR*wh;
1415     WINE_WAVEOUT *wwo;
1416
1417     TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
1418     
1419     /* first, do the sanity checks... */
1420     if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1421     {
1422       WARN("bad dev ID !\n");
1423       return MMSYSERR_BADDEVICEID;
1424     }
1425
1426     wwo = &WOutDev[wDevID];
1427
1428     if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
1429     {
1430       TRACE("unprepared\n");
1431       return WAVERR_UNPREPARED;
1432     }
1433     
1434     if (lpWaveHdr->dwFlags & WHDR_INQUEUE) 
1435     {
1436       TRACE("still playing\n");
1437       return WAVERR_STILLPLAYING;
1438     }
1439
1440     lpWaveHdr->dwFlags &= ~WHDR_DONE;
1441     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1442     lpWaveHdr->lpNext = 0;
1443
1444     EnterCriticalSection(&wwo->access_crst);
1445
1446     /* insert buffer at the end of queue */
1447     for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
1448     *wh = lpWaveHdr;
1449
1450     if (!wwo->lpPlayPtr)
1451       wodHelper_BeginWaveHdr(wwo,lpWaveHdr);
1452     if (wwo->state == WINE_WS_STOPPED)
1453       wwo->state = WINE_WS_PLAYING;
1454     LeaveCriticalSection(&wwo->access_crst);
1455
1456     return MMSYSERR_NOERROR;
1457 }
1458
1459 /**************************************************************************
1460  *                      wodPause                                [internal]
1461  */
1462 static DWORD wodPause(WORD wDevID)
1463 {
1464   TRACE("(%u);!\n", wDevID);
1465     
1466   if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1467   {
1468     WARN("bad device ID !\n");
1469     return MMSYSERR_BADDEVICEID;
1470   }
1471     
1472   TRACE("[3-PAUSING]\n");
1473
1474   EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1475   wodHelper_Reset(&WOutDev[wDevID], FALSE);
1476   LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1477
1478   return MMSYSERR_NOERROR;
1479 }
1480
1481 /**************************************************************************
1482  *                      wodRestart                              [internal]
1483  */
1484 static DWORD wodRestart(WORD wDevID)
1485 {
1486     TRACE("(%u);\n", wDevID);
1487
1488     if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1489     {
1490       WARN("bad device ID !\n");
1491       return MMSYSERR_BADDEVICEID;
1492     }
1493
1494     if (WOutDev[wDevID].state == WINE_WS_PAUSED)
1495     {
1496       EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1497       WOutDev[wDevID].state = WINE_WS_PLAYING;
1498       LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1499     }
1500     
1501     return MMSYSERR_NOERROR;
1502 }
1503
1504 /**************************************************************************
1505  *                      wodReset                                [internal]
1506  */
1507 static DWORD wodReset(WORD wDevID)
1508 {
1509     TRACE("(%u);\n", wDevID);
1510     
1511     if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1512     {
1513       WARN("bad device ID !\n");
1514       return MMSYSERR_BADDEVICEID;
1515     }
1516
1517     EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1518     wodHelper_Reset(&WOutDev[wDevID], TRUE);
1519     LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1520
1521     return MMSYSERR_NOERROR;
1522 }
1523
1524 /**************************************************************************
1525  *                              wodGetPosition                  [internal]
1526  */
1527 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1528 {
1529     DWORD               val;
1530     WINE_WAVEOUT*       wwo;
1531     DWORD elapsedMS;
1532
1533     TRACE("(%u, %p, %u);\n", wDevID, lpTime, uSize);
1534
1535     if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1536     {
1537       WARN("bad device ID !\n");
1538       return MMSYSERR_BADDEVICEID;
1539     }
1540
1541     /* if null pointer to time structure return error */
1542     if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1543
1544     wwo = &WOutDev[wDevID];
1545
1546     EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1547     val = wwo->dwPlayedTotal;
1548     elapsedMS = GetTickCount() - wwo->tickCountMS;
1549     LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1550
1551     /* account for the bytes played since the last JACK_Callback() */
1552     val+=((elapsedMS * wwo->format.wf.nAvgBytesPerSec) / 1000);
1553
1554     return bytes_to_mmtime(lpTime, val, &wwo->format);
1555 }
1556
1557 /**************************************************************************
1558  *                              wodBreakLoop                    [internal]
1559  */
1560 static DWORD wodBreakLoop(WORD wDevID)
1561 {
1562   TRACE("(%u);\n", wDevID);
1563
1564   if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1565   {
1566     WARN("bad device ID !\n");
1567     return MMSYSERR_BADDEVICEID;
1568   }
1569
1570   EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1571
1572   if (WOutDev[wDevID].state == WINE_WS_PLAYING && WOutDev[wDevID].lpLoopPtr != NULL)
1573   {
1574     /* ensure exit at end of current loop */
1575     WOutDev[wDevID].dwLoops = 1;
1576   }
1577
1578   LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1579
1580   return MMSYSERR_NOERROR;
1581 }
1582     
1583 /**************************************************************************
1584  *                              wodGetVolume                    [internal]
1585  */
1586 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1587 {
1588   DWORD left, right;
1589     
1590   left = WOutDev[wDevID].volume_left;
1591   right = WOutDev[wDevID].volume_right;
1592         
1593   TRACE("(%u, %p);\n", wDevID, lpdwVol);
1594  
1595   *lpdwVol = ((left * 0xFFFFl) / 100) + (((right * 0xFFFFl) / 100) <<
1596               16);
1597     
1598   return MMSYSERR_NOERROR;
1599 }
1600
1601 /**************************************************************************
1602  *                              wodSetVolume                    [internal]
1603  */
1604 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1605 {
1606   DWORD left, right;
1607  
1608   left  = (LOWORD(dwParam) * 100) / 0xFFFFl;
1609   right = (HIWORD(dwParam) * 100) / 0xFFFFl;
1610  
1611   TRACE("(%u, %08X);\n", wDevID, dwParam);
1612
1613   EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1614
1615   WOutDev[wDevID].volume_left = left;
1616   WOutDev[wDevID].volume_right = right;
1617
1618   LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1619
1620   return MMSYSERR_NOERROR;
1621 }
1622
1623 /**************************************************************************
1624  *                              wodGetNumDevs                   [internal]
1625  */
1626 static DWORD wodGetNumDevs(void)
1627 {
1628   return MAX_WAVEOUTDRV;
1629 }
1630
1631 /**************************************************************************
1632  *                              wodDevInterfaceSize             [internal]
1633  */
1634 static DWORD wodDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
1635 {
1636     TRACE("(%u, %p)\n", wDevID, dwParam1);
1637                                                                                                        
1638     *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1639                                     NULL, 0 ) * sizeof(WCHAR);
1640     return MMSYSERR_NOERROR;
1641 }
1642
1643 /**************************************************************************
1644  *                              wodDevInterface                 [internal]
1645  */
1646 static DWORD wodDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
1647 {
1648     if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1649                                         NULL, 0 ) * sizeof(WCHAR))
1650     {
1651         MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1652                             dwParam1, dwParam2 / sizeof(WCHAR));
1653         return MMSYSERR_NOERROR;
1654     }
1655     return MMSYSERR_INVALPARAM;
1656 }
1657
1658 /**************************************************************************
1659  *                              wodMessage (WINEJACK.7)
1660  */
1661 DWORD WINAPI JACK_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
1662                              DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1663 {
1664   TRACE("(%u, %04X, %08X, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
1665
1666   switch (wMsg) {
1667   case DRVM_INIT:
1668   case DRVM_EXIT:
1669   case DRVM_ENABLE:
1670   case DRVM_DISABLE:
1671     /* FIXME: Pretend this is supported */
1672     return 0;
1673   case WODM_OPEN:             return wodOpen(wDevID, (LPWAVEOPENDESC)dwParam1,  dwParam2);
1674   case WODM_CLOSE:            return wodClose(wDevID);
1675   case WODM_WRITE:            return wodWrite(wDevID, (LPWAVEHDR)dwParam1,              dwParam2);
1676   case WODM_PAUSE:            return wodPause(wDevID);
1677   case WODM_GETPOS:           return wodGetPosition(wDevID, (LPMMTIME)dwParam1,                 dwParam2);
1678   case WODM_BREAKLOOP:        return wodBreakLoop(wDevID);
1679   case WODM_PREPARE:          return MMSYSERR_NOTSUPPORTED;
1680   case WODM_UNPREPARE:        return MMSYSERR_NOTSUPPORTED;
1681   case WODM_GETDEVCAPS:       return wodGetDevCaps(wDevID, (LPWAVEOUTCAPSW)dwParam1,    dwParam2);
1682   case WODM_GETNUMDEVS:       return wodGetNumDevs();
1683   case WODM_GETPITCH:         return MMSYSERR_NOTSUPPORTED;
1684   case WODM_SETPITCH:         return MMSYSERR_NOTSUPPORTED;
1685   case WODM_GETPLAYBACKRATE:    return MMSYSERR_NOTSUPPORTED;
1686   case WODM_SETPLAYBACKRATE:    return MMSYSERR_NOTSUPPORTED;
1687   case WODM_GETVOLUME:        return wodGetVolume(wDevID, (LPDWORD)dwParam1);
1688   case WODM_SETVOLUME:        return wodSetVolume(wDevID, dwParam1);
1689   case WODM_RESTART:          return wodRestart(wDevID);
1690   case WODM_RESET:            return wodReset(wDevID);
1691
1692   case DRV_QUERYDEVICEINTERFACESIZE: return wodDevInterfaceSize       (wDevID, (LPDWORD)dwParam1);
1693   case DRV_QUERYDEVICEINTERFACE:     return wodDevInterface           (wDevID, (PWCHAR)dwParam1, dwParam2);
1694   case DRV_QUERYDSOUNDIFACE:    return wodDsCreate(wDevID, (PIDSDRIVER*)dwParam1);
1695   case DRV_QUERYDSOUNDDESC:     return wodDsDesc(wDevID, (PDSDRIVERDESC)dwParam1);
1696   default:
1697     FIXME("unknown message %d!\n", wMsg);
1698     }
1699     return MMSYSERR_NOTSUPPORTED;
1700 }
1701
1702 /*======================================================================*
1703  *                  Low level DSOUND implementation                     *
1704  *======================================================================*/
1705
1706 typedef struct IDsDriverImpl IDsDriverImpl;
1707 typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
1708
1709 struct IDsDriverImpl
1710 {
1711     /* IUnknown fields */
1712     const IDsDriverVtbl *lpVtbl;
1713     DWORD               ref;
1714     /* IDsDriverImpl fields */
1715     UINT                wDevID;
1716     IDsDriverBufferImpl*primary;
1717 };
1718
1719 struct IDsDriverBufferImpl
1720 {
1721     /* IUnknown fields */
1722     const IDsDriverBufferVtbl *lpVtbl;
1723     DWORD ref;
1724     /* IDsDriverBufferImpl fields */
1725     IDsDriverImpl* drv;
1726     DWORD buflen;
1727 };
1728
1729 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
1730 {
1731     /* we can't perform memory mapping as we don't have a file stream 
1732       interface with jack like we do with oss */
1733     MESSAGE("This sound card's driver does not support direct access\n");
1734     MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
1735     return MMSYSERR_NOTSUPPORTED;
1736 }
1737
1738 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc)
1739 {
1740     memset(desc, 0, sizeof(*desc));
1741     strcpy(desc->szDesc, "Wine jack DirectSound Driver");
1742     strcpy(desc->szDrvname, "winejack.drv");
1743     return MMSYSERR_NOERROR;
1744 }
1745
1746 /*======================================================================*
1747  *                  Low level WAVE IN implementation                    *
1748  *======================================================================*/
1749
1750 /**************************************************************************
1751  *                      widNotifyClient                 [internal]
1752  */
1753 static DWORD widNotifyClient(WINE_WAVEIN* wwi, WORD wMsg, DWORD_PTR dwParam1,
1754                              DWORD_PTR dwParam2)
1755 {
1756     TRACE("wMsg = %04X dwParm1 = %08lX dwParam2 = %08lX\n", wMsg, dwParam1, dwParam2);
1757
1758     switch (wMsg) {
1759     case WIM_OPEN:
1760     case WIM_CLOSE:
1761     case WIM_DATA:
1762       if (wwi->wFlags != DCB_NULL &&
1763         !DriverCallback(wwi->waveDesc.dwCallback, wwi->wFlags,
1764           (HDRVR)wwi->waveDesc.hWave, wMsg, wwi->waveDesc.dwInstance,
1765           dwParam1, dwParam2))
1766       {
1767         WARN("can't notify client !\n");
1768         return MMSYSERR_ERROR;
1769       }
1770     break;
1771     default:
1772       FIXME("Unknown callback message %u\n", wMsg);
1773         return MMSYSERR_INVALPARAM;
1774     }
1775     return MMSYSERR_NOERROR;
1776 }
1777
1778 /******************************************************************
1779  *    JACK_callback_wwi
1780  */
1781 /* everytime the jack server wants something from us it calls this 
1782    function */
1783 static int JACK_callback_wwi (nframes_t nframes, void *arg)
1784 {
1785     sample_t* in_l;
1786     sample_t* in_r = 0;
1787     WINE_WAVEIN* wwi = arg;
1788
1789     TRACE("wDevID: %u, nframes %u\n", wwi->wDevID, nframes);
1790     
1791     if(!wwi->client)
1792         ERR("client is closed, this is weird...\n");
1793
1794     in_l = fp_jack_port_get_buffer(wwi->in_port_l, nframes);
1795
1796     if (wwi->in_port_r)
1797       in_r = fp_jack_port_get_buffer(wwi->in_port_r, nframes);
1798
1799     EnterCriticalSection(&wwi->access_crst);
1800     
1801     if((wwi->lpQueuePtr != NULL) && (wwi->state == WINE_WS_PLAYING))
1802     {
1803         LPWAVEHDR lpWaveHdr = wwi->lpQueuePtr;
1804         nframes_t jackFramesLeft = nframes;
1805
1806 #if JACK_CLOSE_HACK
1807         if(wwi->in_use == FALSE)
1808         {
1809             /* do nothing if nothing is being recorded */
1810             LeaveCriticalSection(&wwi->access_crst);
1811             return 0;
1812         }
1813 #endif
1814         
1815         TRACE("wwi.state == WINE_WS_PLAYING\n");
1816         
1817         while (lpWaveHdr && jackFramesLeft)
1818         {
1819             DWORD waveHdrFramesLeft = (lpWaveHdr->dwBufferLength - lpWaveHdr->dwBytesRecorded) / (sizeof(short) * wwi->format.wf.nChannels); 
1820             DWORD numFrames = min (jackFramesLeft, waveHdrFramesLeft);
1821             
1822             TRACE ("dwBufferLength=(%u) dwBytesRecorded=(%d)\n",   lpWaveHdr->dwBufferLength, lpWaveHdr->dwBytesRecorded);
1823             TRACE ("jackFramesLeft=(%u) waveHdrFramesLeft=(%u)\n", jackFramesLeft, waveHdrFramesLeft);
1824
1825             if (!in_r) {
1826               /* mono */
1827               sample_move_s16_d16((short *)((char *)lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded), in_l+(nframes-jackFramesLeft), numFrames, 1);
1828             } else {
1829               /* stereo */
1830               sample_move_s16_d16((short *)((char *)lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded), 
1831                                   in_l+(nframes-jackFramesLeft), numFrames, 2);
1832               sample_move_s16_d16((short *)((char *)lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded + sizeof(short)), 
1833                                   in_r+(nframes-jackFramesLeft), numFrames, 2);
1834             }
1835             
1836             lpWaveHdr->dwBytesRecorded += (numFrames * sizeof(short) * wwi->format.wf.nChannels );
1837             jackFramesLeft -= numFrames;
1838
1839             if (lpWaveHdr->dwBytesRecorded >= lpWaveHdr->dwBufferLength)
1840             {
1841                 /* must copy the value of next waveHdr, because we have no idea of what
1842                  * will be done with the content of lpWaveHdr in callback
1843                  */
1844                 LPWAVEHDR       lpNext = lpWaveHdr->lpNext;
1845                                 
1846                 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1847                 lpWaveHdr->dwFlags |=  WHDR_DONE;
1848
1849                 TRACE("WaveHdr full. dwBytesRecorded=(%u) dwFlags=(0x%x)\n",lpWaveHdr->dwBytesRecorded,lpWaveHdr->dwFlags);
1850
1851                 widNotifyClient(wwi, WIM_DATA, (DWORD_PTR)lpWaveHdr, 0);
1852
1853                 lpWaveHdr = wwi->lpQueuePtr = lpNext;
1854             }
1855         }
1856         TRACE ("jackFramesLeft=(%u) lpWaveHdr=(%p)\n", jackFramesLeft, lpWaveHdr);
1857         if (jackFramesLeft > 0) { WARN("Record buffer ran out of WaveHdrs\n"); }
1858     }
1859     
1860     LeaveCriticalSection(&wwi->access_crst);
1861
1862     return 0;
1863 }
1864
1865 /******************************************************************
1866  *              JACK_OpenWaveInDevice
1867  */
1868 static int JACK_OpenWaveInDevice(WINE_WAVEIN* wwi, WORD nChannels)
1869 {
1870   const char** ports;
1871   int i;
1872   char client_name[64];
1873   jack_port_t* in_port_l;
1874   jack_port_t* in_port_r = 0;
1875   jack_client_t* client;
1876   int failed = 0;
1877
1878   TRACE("creating jack client and setting up callbacks\n");
1879
1880   if ((nChannels == 0) || (nChannels > 2)) {
1881     ERR ("nChannels = (%d), but we only support mono or stereo.\n", nChannels);
1882     return 0;
1883   }
1884
1885 #if JACK_CLOSE_HACK
1886   /* see if this device is already open */
1887         if(wwi->client)
1888         {
1889           /* if this device is already in use then it is bad for us to be in here */
1890           if(wwi->in_use)
1891             return 0;
1892
1893           TRACE("using existing client\n");
1894           wwi->in_use = TRUE;
1895           return 1;
1896         }
1897 #endif
1898
1899         /* zero out the buffer pointer and the size of the buffer */
1900         wwi->sound_buffer = 0;
1901         wwi->buffer_size = 0;
1902
1903         /* try to become a client of the JACK server */
1904         snprintf(client_name, sizeof(client_name), "wine_jack_in_%d", wwi->wDevID);
1905         TRACE("client name '%s'\n", client_name);
1906         if ((client = fp_jack_client_new (client_name)) == 0)
1907         {
1908                 /* jack has problems with shutting down clients, so lets */
1909                 /* wait a short while and try once more before we give up */
1910                 Sleep(250);
1911                 if ((client = fp_jack_client_new (client_name)) == 0)
1912                 {
1913                   ERR("jack server not running?\n");
1914                   return 0;
1915                 }
1916         }
1917         wwi->client = client;
1918                 
1919         /* tell the JACK server to call `JACK_wwi_callback()' whenever
1920            there is work to be done. */
1921         fp_jack_set_process_callback (client, JACK_callback_wwi, wwi);
1922         
1923         /* tell the JACK server to call `JACK_bufsize_wwi()' whenever   
1924            the maximum number of frames that will be passed
1925            to `JACK_Callback()' changes */
1926         fp_jack_set_buffer_size_callback (client, JACK_bufsize_wwi, wwi);
1927           
1928         /* tell the JACK server to call `srate()' whenever
1929            the sample rate of the system changes. */
1930         fp_jack_set_sample_rate_callback (client, JACK_srate, wwi);
1931
1932         /* tell the JACK server to call `jack_shutdown()' if
1933            it ever shuts down, either entirely, or if it
1934            just decides to stop calling us. */
1935         fp_jack_on_shutdown (client, JACK_shutdown_wwi, wwi);
1936         
1937         /* display the current sample rate. once the client is activated
1938            (see below), you should rely on your own sample rate
1939            callback (see above) for this value. */
1940         wwi->sample_rate = fp_jack_get_sample_rate(client);
1941         TRACE("engine sample rate: %lu\n", wwi->sample_rate);
1942           
1943         /* create the left and right channel output ports */
1944         /* jack's ports are all mono so for stereo you need two */
1945         in_port_l = fp_jack_port_register (client, "in_l",
1946                          JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1947         wwi->in_port_l = in_port_l;
1948         TRACE("Created port. (%p)\n", in_port_l);
1949
1950         if (nChannels == 2)
1951         {
1952           in_port_r = fp_jack_port_register (client, "in_r",
1953                            JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0); 
1954           TRACE("Created port. (%p)\n", in_port_r);
1955         } 
1956         wwi->in_port_r = in_port_r;
1957
1958 #if JACK_CLOSE_HACK
1959         wwi->in_use = TRUE; /* mark this device as in use since it now is ;-) */
1960 #endif
1961
1962         TRACE("activating client.\n");
1963         /* tell the JACK server that we are ready to roll */
1964         if (fp_jack_activate (client))
1965         {
1966           ERR( "cannot activate client\n");
1967           return 0;
1968         }
1969         TRACE("activated client.\n");
1970         /* figure out what the ports that we want to output on are */
1971         /* NOTE: we do this instead of using stuff like "alsa_pcm:playback_X" because */
1972         /*   this way works if names are changed */
1973         ports = fp_jack_get_ports(client, NULL, NULL, JackPortIsPhysical|JackPortIsOutput);
1974
1975         /* display a trace of the output ports we found */
1976         for(i = 0; ports[i]; i++)
1977         {
1978           TRACE("ports[%d] = '%s'\n", i, ports[i]);
1979         }
1980
1981         if(!ports)
1982         {
1983           ERR("jack_get_ports() failed to find 'JackPortIsPhysical|JackPortIsOutput'\n");
1984         }
1985
1986         /* connect the ports. Note: you can't do this before
1987            the client is activated (this may change in the future).
1988         */ 
1989         /* we want to connect to two ports so we have stereo input ;-) */
1990
1991         if(fp_jack_connect(client, ports[0], fp_jack_port_name(in_port_l)))
1992         {
1993           ERR ("cannot connect to input port %d('%s')\n", 0, ports[0]);
1994           failed = 1;
1995         }
1996         TRACE("Connected (%s)<->(%s)\n",ports[0],fp_jack_port_name(in_port_l));
1997
1998         if ((nChannels == 2) && in_port_r) {
1999           if(fp_jack_connect(client, ports[1], fp_jack_port_name(in_port_r)))
2000           {
2001             ERR ("cannot connect to input port %d('%s')\n", 1, ports[1]);
2002             failed = 1;
2003           }
2004           TRACE("Connected (%s)<->(%s)\n",ports[1],fp_jack_port_name(in_port_r));
2005         }
2006         free(ports); /* free the returned array of ports */
2007
2008         /* if something failed we need to shut the client down and return 0 */
2009         if(failed)
2010         {
2011 #if JACK_CLOSE_HACK
2012           JACK_CloseWaveInDevice(wwi, TRUE);
2013 #else
2014           JACK_CloseWaveInDevice(wwi);
2015 #endif
2016           return 0;
2017         }
2018
2019         TRACE("return success.\n");
2020         return 1; /* return success */
2021 }
2022
2023 /**************************************************************************
2024  *                      widGetDevCaps                           [internal]
2025  */
2026 static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPSW lpCaps, DWORD dwSize)
2027 {
2028     TRACE("(%u, %p, %u);\n", wDevID, lpCaps, dwSize);
2029
2030     if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
2031
2032     if (wDevID >= MAX_WAVEINDRV) {
2033         TRACE("MAX_WAVEINDRV reached !\n");
2034         return MMSYSERR_BADDEVICEID;
2035     }
2036
2037     memcpy(lpCaps, &WInDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
2038     return MMSYSERR_NOERROR;
2039 }
2040
2041 /**************************************************************************
2042  *                              widOpen                         [internal]
2043  */
2044 static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
2045 {
2046     WINE_WAVEIN*        wwi;
2047     DWORD retval;
2048
2049     TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
2050     if (lpDesc == NULL)
2051     {
2052         WARN("Invalid Parameter !\n");
2053         return MMSYSERR_INVALPARAM;
2054     }
2055     if (wDevID >= MAX_WAVEINDRV) {
2056         TRACE ("MAX_WAVEINDRV reached !\n");
2057         return MMSYSERR_BADDEVICEID;
2058     }
2059
2060 #if JACK_CLOSE_HACK
2061     if(WInDev[wDevID].client && WOutDev[wDevID].in_use)
2062 #else
2063     if(WInDev[wDevID].client)
2064 #endif
2065     {
2066       TRACE("device %d already allocated\n", wDevID);
2067       return MMSYSERR_ALLOCATED;
2068     }
2069
2070     /* Only the PCM format is supported so far...
2071      * Also we only support 16 bit mode.
2072      */
2073     if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
2074       lpDesc->lpFormat->nChannels == 0 ||
2075       lpDesc->lpFormat->nSamplesPerSec == 0 ||
2076       lpDesc->lpFormat->wBitsPerSample!=16)
2077     {
2078       WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d wBitsPerSample=%d !\n",
2079        lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
2080        lpDesc->lpFormat->nSamplesPerSec, lpDesc->lpFormat->wBitsPerSample);
2081       return WAVERR_BADFORMAT;
2082     }
2083
2084     if (dwFlags & WAVE_FORMAT_QUERY)
2085     {
2086       TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
2087        lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
2088        lpDesc->lpFormat->nSamplesPerSec);
2089       return MMSYSERR_NOERROR;
2090     }
2091
2092     wwi = &WInDev[wDevID];
2093     wwi->wDevID = wDevID;
2094
2095     /* Set things up before we call JACK_OpenWaveOutDevice because */
2096     /* we will start getting callbacks before JACK_OpenWaveOutDevice */
2097     /* even returns and we want to be initialized before then */
2098     wwi->state = WINE_WS_STOPPED; /* start in a stopped state */
2099
2100     InitializeCriticalSection(&wwi->access_crst); /* initialize the critical section */
2101     EnterCriticalSection(&wwi->access_crst);
2102
2103     /* open up jack ports for this device */
2104     if (!JACK_OpenWaveInDevice(&WInDev[wDevID], lpDesc->lpFormat->nChannels))
2105     {
2106       ERR("JACK_OpenWaveInDevice(%d) failed\n", wDevID);
2107       LeaveCriticalSection(&wwi->access_crst);
2108       DeleteCriticalSection(&wwi->access_crst);
2109       return MMSYSERR_ERROR;            /* return unspecified error */
2110     }
2111
2112     dwFlags &= ~WAVE_DIRECTSOUND;  /* direct sound not supported, ignore the flag */
2113
2114     wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
2115
2116     wwi->waveDesc = *lpDesc;
2117     memcpy(&wwi->format,   lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
2118
2119     LeaveCriticalSection(&wwi->access_crst);
2120
2121     /* display the current wave format */
2122     TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
2123     wwi->format.wBitsPerSample, wwi->format.wf.nAvgBytesPerSec,
2124     wwi->format.wf.nSamplesPerSec, wwi->format.wf.nChannels,
2125     wwi->format.wf.nBlockAlign);
2126
2127     /* make sure that we have the same sample rate in our audio stream */
2128     /* as we do in the jack server */
2129     if(wwi->format.wf.nSamplesPerSec != wwi->sample_rate)
2130     {
2131       TRACE("error: jack server sample rate is '%ld', wave sample rate is '%d'\n",
2132          wwi->sample_rate, wwi->format.wf.nSamplesPerSec);
2133
2134 #if JACK_CLOSE_HACK
2135       JACK_CloseWaveInDevice(wwi, FALSE); /* close this device, don't force the client to close */
2136 #else
2137       JACK_CloseWaveInDevice(wwi); /* close this device */
2138 #endif
2139       DeleteCriticalSection(&wwi->access_crst);
2140       return WAVERR_BADFORMAT;
2141     }
2142
2143     /* check for an invalid number of bits per sample */
2144     if (wwi->format.wBitsPerSample == 0)
2145     {
2146       WARN("Resetting zeroed wBitsPerSample\n");
2147       wwi->format.wBitsPerSample = 8 *
2148       (wwi->format.wf.nAvgBytesPerSec /
2149        wwi->format.wf.nSamplesPerSec) /
2150        wwi->format.wf.nChannels;
2151     }
2152
2153     TRACE("notify client.\n");
2154     EnterCriticalSection(&wwi->access_crst);
2155     retval = widNotifyClient(wwi, WIM_OPEN, 0, 0);
2156     LeaveCriticalSection(&wwi->access_crst);
2157
2158     return retval;
2159 }
2160 /**************************************************************************
2161  *                              widClose                        [internal]
2162  */
2163 static DWORD widClose(WORD wDevID)
2164 {
2165     DWORD               ret = MMSYSERR_NOERROR;
2166     WINE_WAVEIN*        wwi;
2167
2168     TRACE("(%u);\n", wDevID);
2169
2170     if (wDevID >= MAX_WAVEINDRV || !WInDev[wDevID].client)
2171     {
2172       WARN("bad device ID !\n");
2173       return MMSYSERR_BADDEVICEID;
2174     }
2175     
2176     wwi = &WInDev[wDevID];
2177     if (wwi->lpQueuePtr)
2178     {
2179       WARN("buffers still playing !\n");
2180       ret = WAVERR_STILLPLAYING;
2181     } else
2182     {
2183         /* sanity check: this should not happen since the device must have been reset before */
2184         if (wwi->lpQueuePtr) ERR("out of sync\n");
2185         
2186         wwi->state = WINE_WS_CLOSED; /* mark the device as closed */
2187         
2188 #if JACK_CLOSE_HACK
2189         JACK_CloseWaveInDevice(wwi, FALSE); /* close the jack device, DO NOT force the client to close */
2190 #else
2191         JACK_CloseWaveInDevice(wwi); /* close the jack device */
2192 #endif
2193         DeleteCriticalSection(&wwi->access_crst); /* delete the critical section so we can initialize it again from wodOpen() */
2194
2195         ret = widNotifyClient(wwi, WIM_CLOSE, 0, 0);
2196     }
2197
2198     return ret;
2199 }
2200
2201 /**************************************************************************
2202  *                              widAddBuffer            [internal]
2203  */
2204 static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
2205 {
2206     WINE_WAVEIN* wwi = &WInDev[wDevID];
2207
2208     TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
2209
2210     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2211                                 WARN("can't do it !\n");
2212                                 return MMSYSERR_INVALHANDLE;
2213     }
2214     if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) {
2215                                 TRACE("never been prepared !\n");
2216                                 return WAVERR_UNPREPARED;
2217     }
2218     if (lpWaveHdr->dwFlags & WHDR_INQUEUE) {
2219                                 TRACE("header already in use !\n");
2220                                 return WAVERR_STILLPLAYING;
2221     }
2222
2223     lpWaveHdr->dwFlags |= WHDR_INQUEUE;
2224     lpWaveHdr->dwFlags &= ~WHDR_DONE;
2225     lpWaveHdr->dwBytesRecorded = 0;
2226     lpWaveHdr->lpNext = NULL;
2227
2228     EnterCriticalSection(&wwi->access_crst);
2229     /* insert buffer at end of queue */
2230     {
2231         LPWAVEHDR* wh;
2232         for (wh = &(wwi->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
2233         *wh=lpWaveHdr;
2234     }
2235     LeaveCriticalSection(&wwi->access_crst);
2236
2237     return MMSYSERR_NOERROR;
2238 }
2239
2240 /**************************************************************************
2241  *                      widStart                                [internal]
2242  */
2243 static DWORD widStart(WORD wDevID)
2244 {
2245     TRACE("(%u);\n", wDevID);
2246     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2247         WARN("can't start recording !\n");
2248         return MMSYSERR_INVALHANDLE;
2249     }
2250
2251     WInDev[wDevID].state = WINE_WS_PLAYING;
2252     return MMSYSERR_NOERROR;
2253 }
2254
2255 /**************************************************************************
2256  *                      widStop                                 [internal]
2257  */
2258 static DWORD widStop(WORD wDevID)
2259 {
2260     WINE_WAVEIN* wwi = &WInDev[wDevID];
2261
2262     TRACE("(%u);\n", wDevID);
2263     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2264         WARN("can't stop !\n");
2265         return MMSYSERR_INVALHANDLE;
2266     }
2267     
2268     if (wwi->state != WINE_WS_STOPPED)
2269     {
2270         WAVEHDR*                lpWaveHdr;
2271         /* do something here to stop recording ??? */
2272         
2273         /* return current buffer to app */
2274         lpWaveHdr = wwi->lpQueuePtr;
2275         if (lpWaveHdr)
2276         {
2277             LPWAVEHDR   lpNext = lpWaveHdr->lpNext;
2278             TRACE("stop %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
2279             lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2280             lpWaveHdr->dwFlags |= WHDR_DONE;
2281             widNotifyClient(wwi, WIM_DATA, (DWORD_PTR)lpWaveHdr, 0);
2282             wwi->lpQueuePtr = lpNext;
2283         }
2284     }
2285     wwi->state = WINE_WS_STOPPED;
2286
2287     return MMSYSERR_NOERROR;
2288 }
2289
2290 /**************************************************************************
2291  *                      widReset                                [internal]
2292  */
2293 static DWORD widReset(WORD wDevID)
2294 {
2295     WINE_WAVEIN* wwi = &WInDev[wDevID];
2296     WAVEHDR*            lpWaveHdr;
2297
2298     TRACE("(%u);\n", wDevID);
2299     if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2300         WARN("can't reset !\n");
2301         return MMSYSERR_INVALHANDLE;
2302     }
2303
2304     wwi->state = WINE_WS_STOPPED;
2305
2306     /* return all buffers to the app */
2307     for (lpWaveHdr = wwi->lpQueuePtr; lpWaveHdr; lpWaveHdr = lpWaveHdr->lpNext) {
2308         TRACE("reset %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
2309         lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2310         lpWaveHdr->dwFlags |= WHDR_DONE;
2311
2312         widNotifyClient(wwi, WIM_DATA, (DWORD_PTR)lpWaveHdr, 0);
2313     }
2314     wwi->lpQueuePtr = NULL;
2315
2316     return MMSYSERR_NOERROR;
2317 }
2318
2319 /**************************************************************************
2320  *                              widGetNumDevs                   [internal]
2321  */
2322 static DWORD widGetNumDevs(void)
2323 {
2324   return MAX_WAVEINDRV;
2325 }
2326
2327 /**************************************************************************
2328  *                              widDevInterfaceSize             [internal]
2329  */
2330 static DWORD widDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
2331 {
2332     TRACE("(%u, %p)\n", wDevID, dwParam1);
2333                                                                                                        
2334                                                                                                        
2335     *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2336                                     NULL, 0 ) * sizeof(WCHAR);
2337     return MMSYSERR_NOERROR;
2338 }
2339
2340 /**************************************************************************
2341  *                              widDevInterface                 [internal]
2342  */
2343 static DWORD widDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
2344 {
2345     if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2346                                         NULL, 0 ) * sizeof(WCHAR))
2347     {
2348         MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2349                             dwParam1, dwParam2 / sizeof(WCHAR));
2350         return MMSYSERR_NOERROR;
2351     }
2352     return MMSYSERR_INVALPARAM;
2353 }
2354
2355 /**************************************************************************
2356  *                              widMessage (WINEJACK.6)
2357  */
2358 DWORD WINAPI JACK_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2359                              DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2360 {
2361   TRACE("(%u, %04X, %08X, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2362
2363     switch (wMsg) {
2364     case DRVM_INIT:
2365     case DRVM_EXIT:
2366     case DRVM_ENABLE:
2367     case DRVM_DISABLE:
2368         /* FIXME: Pretend this is supported */
2369         return 0;
2370     case WIDM_OPEN:             return widOpen          (wDevID, (LPWAVEOPENDESC)dwParam1,      dwParam2);
2371     case WIDM_CLOSE:            return widClose         (wDevID);
2372     case WIDM_ADDBUFFER:        return widAddBuffer     (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
2373     case WIDM_PREPARE:          return MMSYSERR_NOTSUPPORTED;
2374     case WIDM_UNPREPARE:        return MMSYSERR_NOTSUPPORTED;
2375     case WIDM_GETDEVCAPS:       return widGetDevCaps    (wDevID, (LPWAVEINCAPSW)dwParam1,       dwParam2);
2376     case WIDM_GETNUMDEVS:       return widGetNumDevs();
2377     case WIDM_RESET:            return widReset         (wDevID);
2378     case WIDM_START:            return widStart         (wDevID);
2379     case WIDM_STOP:             return widStop          (wDevID);
2380     case DRV_QUERYDEVICEINTERFACESIZE: return widDevInterfaceSize       (wDevID, (LPDWORD)dwParam1);
2381     case DRV_QUERYDEVICEINTERFACE:     return widDevInterface           (wDevID, (PWCHAR)dwParam1, dwParam2);
2382     default:
2383         FIXME("unknown message %d!\n", wMsg);
2384     }
2385
2386   return MMSYSERR_NOTSUPPORTED;
2387 }
2388
2389 #else /* !SONAME_LIBJACK */
2390
2391 /**************************************************************************
2392  *                              widMessage (WINEJACK.6)
2393  */
2394 DWORD WINAPI JACK_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2395                              DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2396 {
2397   FIXME("(%u, %04X, %08X, %08lX, %08lX):jack support not compiled into wine\n",
2398         wDevID, wMsg, dwUser, dwParam1, dwParam2);
2399   return MMSYSERR_NOTENABLED;
2400 }
2401
2402 /**************************************************************************
2403  *                              wodMessage (WINEJACK.7)
2404  */
2405 DWORD WINAPI JACK_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2406                              DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2407 {
2408   FIXME("(%u, %04X, %08X, %08lX, %08lX):jack support not compiled into wine\n",
2409         wDevID, wMsg, dwUser, dwParam1, dwParam2);
2410   return MMSYSERR_NOTENABLED;
2411 }
2412
2413 #endif /* SONAME_LIBJACK */