?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winejack.drv: Add DebugInfo to critical sections
[wine/hacks.git] / dlls / winejack.drv / audio.c
blob9356f8e1cf858258c32f526a891081c70aa4c038
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_open" */
72 MAKE_FUNCPTR(jack_activate);
73 MAKE_FUNCPTR(jack_connect);
74 MAKE_FUNCPTR(jack_client_open);
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 * (unsigned)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_open (client_name, JackUseExactName, NULL)) == 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_open (client_name, JackUseExactName, NULL)) == 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 static int WAVE_loadcount;
838
839 /******************************************************************
840 * JACK_WaveRelease
841 *
842 *
843 */
844 static LONG JACK_WaveRelease(void)
845 {
846 int iDevice;
847
848 if (--WAVE_loadcount)
849 return 1;
850 TRACE("closing all open waveout devices\n");
851
852 /* close all open output devices */
853 for(iDevice = 0; iDevice < MAX_WAVEOUTDRV; iDevice++)
854 {
855 TRACE("iDevice == %d\n", iDevice);
856 if(WOutDev[iDevice].client)
857 {
858 #if JACK_CLOSE_HACK
859 JACK_CloseWaveOutDevice(&WOutDev[iDevice], TRUE); /* close the device, FORCE the client to close */
860 #else
861 JACK_CloseWaveOutDevice(&WOutDev[iDevice]); /* close the device, FORCE the client to close */
862 #endif
863 #if JACK_CLOSE_HACK
864 if(WOutDev[iDevice].in_use) {
865 #endif
866 WOutDev[iDevice].access_crst.DebugInfo->Spare[0] = 0;
867 DeleteCriticalSection(&(WOutDev[iDevice].access_crst)); /* delete the critical section */
868 #if JACK_CLOSE_HACK
869 }
870 #endif
871 }
872 }
873
874 TRACE("closing all open wavein devices\n");
875
876 /* close all open input devices */
877 for(iDevice = 0; iDevice < MAX_WAVEINDRV; iDevice++)
878 {
879 TRACE("iDevice == %d\n", iDevice);
880 if(WInDev[iDevice].client)
881 {
882 #if JACK_CLOSE_HACK
883 JACK_CloseWaveInDevice(&WInDev[iDevice], TRUE); /* close the device, FORCE the client to close */
884 #else
885 JACK_CloseWaveInDevice(&WInDev[iDevice]); /* close the device, FORCE the client to close */
886 #endif
887 #if JACK_CLOSE_HACK
888 if(WOutDev[iDevice].in_use) {
889 #endif
890 WInDev[iDevice].access_crst.DebugInfo->Spare[0] = 0;
891 DeleteCriticalSection(&(WInDev[iDevice].access_crst)); /* delete the critical section */
892 #if JACK_CLOSE_HACK
893 }
894 #endif
895 }
896 }
897
898 TRACE("returning 1\n");
899
900 return 1;
901 }
902
903 /******************************************************************
904 * JACK_WaveInit
905 *
906 * Initialize internal structures from JACK server info
907 */
908 static LONG JACK_WaveInit(void)
909 {
910 int i;
911 CHAR szPname[MAXPNAMELEN];
912
913 TRACE("called\n");
914 if (WAVE_loadcount++)
915 return 1;
916
917 /* setup function pointers */
918 #define LOAD_FUNCPTR(f) if((fp_##f = wine_dlsym(jackhandle, #f, NULL, 0)) == NULL) goto sym_not_found;
919 LOAD_FUNCPTR(jack_activate);
920 LOAD_FUNCPTR(jack_connect);
921 LOAD_FUNCPTR(jack_client_open);
922 LOAD_FUNCPTR(jack_client_close);
923 LOAD_FUNCPTR(jack_deactivate);
924 LOAD_FUNCPTR(jack_set_process_callback);
925 LOAD_FUNCPTR(jack_set_buffer_size_callback);
926 LOAD_FUNCPTR(jack_set_sample_rate_callback);
927 LOAD_FUNCPTR(jack_on_shutdown);
928 LOAD_FUNCPTR(jack_get_sample_rate);
929 LOAD_FUNCPTR(jack_port_register);
930 LOAD_FUNCPTR(jack_port_get_buffer);
931 LOAD_FUNCPTR(jack_get_ports);
932 LOAD_FUNCPTR(jack_port_name);
933 LOAD_FUNCPTR(jack_get_buffer_size);
934 #undef LOAD_FUNCPTR
935
936 /* start with output device */
937
938 for (i = 0; i < MAX_WAVEOUTDRV; ++i)
939 {
940 WOutDev[i].client = 0; /* initialize the client to 0 */
941
942 #if JACK_CLOSE_HACK
943 WOutDev[i].in_use = FALSE;
944 WInDev[i].in_use = FALSE;
945 #endif
946
947 memset(&WOutDev[i].caps, 0, sizeof(WOutDev[i].caps));
948
949 WOutDev[i].caps.wMid = 0x00FF; /* Manufac ID */
950 WOutDev[i].caps.wPid = 0x0001; /* Product ID */
951 snprintf(szPname, sizeof(szPname), "JACK WaveOut %d", i);
952 MultiByteToWideChar(CP_ACP, 0, szPname, -1, WOutDev[i].caps.szPname, sizeof(WOutDev[i].caps.szPname)/sizeof(WCHAR));
953 snprintf(WOutDev[i].interface_name, sizeof(WOutDev[i].interface_name), "winejack: %d", i);
954
955 WOutDev[i].caps.vDriverVersion = 0x0100;
956 WOutDev[i].caps.dwFormats = 0x00000000;
957 WOutDev[i].caps.dwSupport = WAVECAPS_VOLUME;
958
959 WOutDev[i].caps.wChannels = 2;
960 WOutDev[i].caps.dwSupport |= WAVECAPS_LRVOLUME;
961
962 /* NOTE: we don't support any 8 bit modes so note that */
963 /* WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M08;
964 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S08; */
965 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4S16;
966 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_4M16;
967 /* WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M08;
968 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S08; */
969 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2M16;
970 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_2S16;
971 /* WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M08;
972 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S08;*/
973 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1M16;
974 WOutDev[i].caps.dwFormats |= WAVE_FORMAT_1S16;
975 }
976
977 /* then do input device */
978 for (i = 0; i < MAX_WAVEINDRV; ++i)
979 {
980 /* TODO: we should initialize read stuff here */
981 memset(&WInDev[i].caps, 0, sizeof(WInDev[i].caps));
982
983 WInDev[i].caps.wMid = 0x00FF;
984 WInDev[i].caps.wPid = 0x0001;
985 snprintf(szPname, sizeof(szPname), "JACK WaveIn %d", i);
986 MultiByteToWideChar(CP_ACP, 0, szPname, -1, WInDev[i].caps.szPname, sizeof(WInDev[i].caps.szPname)/sizeof(WCHAR));
987 snprintf(WInDev[i].interface_name, sizeof(WInDev[i].interface_name), "winejack: %d", i);
988
989 WInDev[i].caps.vDriverVersion = 0x0100;
990
991 WInDev[i].caps.wChannels = 0x2;
992 /* NOTE: we don't support any 8 bit modes so note that */
993 /* WInDev[i].caps.dwFormats |= WAVE_FORMAT_4M08;
994 WInDev[i].caps.dwFormats |= WAVE_FORMAT_4S08; */
995 WInDev[i].caps.dwFormats |= WAVE_FORMAT_4S16;
996 WInDev[i].caps.dwFormats |= WAVE_FORMAT_4M16;
997 /* WInDev[i].caps.dwFormats |= WAVE_FORMAT_2M08;
998 WInDev[i].caps.dwFormats |= WAVE_FORMAT_2S08; */
999 WInDev[i].caps.dwFormats |= WAVE_FORMAT_2M16;
1000 WInDev[i].caps.dwFormats |= WAVE_FORMAT_2S16;
1001 /* WInDev[i].caps.dwFormats |= WAVE_FORMAT_1M08;
1002 WInDev[i].caps.dwFormats |= WAVE_FORMAT_1S08;*/
1003 WInDev[i].caps.dwFormats |= WAVE_FORMAT_1M16;
1004 WInDev[i].caps.dwFormats |= WAVE_FORMAT_1S16;
1005 WInDev[i].caps.wReserved1 = 0;
1006 }
1007
1008 return 1; /* return success */
1009
1010 /* error path for function pointer loading errors */
1011 sym_not_found:
1012 WINE_MESSAGE(
1013 "Wine cannot find certain functions that it needs inside the jack"
1014 "library. To enable Wine to use the jack audio server please "
1015 "install libjack\n");
1016 wine_dlclose(jackhandle, NULL, 0);
1017 jackhandle = NULL;
1018 return FALSE;
1019 }
1020
1021 /*======================================================================*
1022 * Low level WAVE OUT implementation *
1023 *======================================================================*/
1024
1025 /**************************************************************************
1026 * wodNotifyClient [internal]
1027 */
1028 static DWORD wodNotifyClient(WINE_WAVEOUT* wwo, WORD wMsg, DWORD_PTR dwParam1,
1029 DWORD_PTR dwParam2)
1030 {
1031 TRACE("wMsg = %04X dwParm1 = %08lX dwParam2 = %08lX\n", wMsg, dwParam1, dwParam2);
1032
1033 switch (wMsg) {
1034 case WOM_OPEN:
1035 case WOM_CLOSE:
1036 case WOM_DONE:
1037 if (wwo->wFlags != DCB_NULL &&
1038 !DriverCallback(wwo->waveDesc.dwCallback, wwo->wFlags,
1039 (HDRVR)wwo->waveDesc.hWave, wMsg, wwo->waveDesc.dwInstance,
1040 dwParam1, dwParam2))
1041 {
1042 WARN("can't notify client !\n");
1043 return MMSYSERR_ERROR;
1044 }
1045 break;
1046 default:
1047 FIXME("Unknown callback message %u\n", wMsg);
1048 return MMSYSERR_INVALPARAM;
1049 }
1050 return MMSYSERR_NOERROR;
1051 }
1052
1053 /**************************************************************************
1054 * wodHelper_BeginWaveHdr [internal]
1055 *
1056 * Makes the specified lpWaveHdr the currently playing wave header.
1057 * If the specified wave header is a begin loop and we're not already in
1058 * a loop, setup the loop.
1059 */
1060 static void wodHelper_BeginWaveHdr(WINE_WAVEOUT* wwo, LPWAVEHDR lpWaveHdr)
1061 {
1062 EnterCriticalSection(&wwo->access_crst);
1063
1064 wwo->lpPlayPtr = lpWaveHdr;
1065
1066 if (!lpWaveHdr)
1067 {
1068 LeaveCriticalSection(&wwo->access_crst);
1069 return;
1070 }
1071
1072 if (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)
1073 {
1074 if (wwo->lpLoopPtr)
1075 {
1076 WARN("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
1077 TRACE("Already in a loop. Discarding loop on this header (%p)\n", lpWaveHdr);
1078 } else
1079 {
1080 TRACE("Starting loop (%dx) with %p\n", lpWaveHdr->dwLoops, lpWaveHdr);
1081 wwo->lpLoopPtr = lpWaveHdr;
1082 /* Windows does not touch WAVEHDR.dwLoops,
1083 * so we need to make an internal copy */
1084 wwo->dwLoops = lpWaveHdr->dwLoops;
1085 }
1086 }
1087 wwo->dwPartialOffset = 0;
1088
1089 LeaveCriticalSection(&wwo->access_crst);
1090 }
1091
1092
1093 /**************************************************************************
1094 * wodHelper_PlayPtrNext [internal]
1095 *
1096 * Advance the play pointer to the next waveheader, looping if required.
1097 */
1098 static LPWAVEHDR wodHelper_PlayPtrNext(WINE_WAVEOUT* wwo)
1099 {
1100 LPWAVEHDR lpWaveHdr;
1101
1102 EnterCriticalSection(&wwo->access_crst);
1103
1104 lpWaveHdr = wwo->lpPlayPtr;
1105
1106 wwo->dwPartialOffset = 0;
1107 if ((lpWaveHdr->dwFlags & WHDR_ENDLOOP) && wwo->lpLoopPtr)
1108 {
1109 /* We're at the end of a loop, loop if required */
1110 if (--wwo->dwLoops > 0)
1111 {
1112 wwo->lpPlayPtr = wwo->lpLoopPtr;
1113 } else
1114 {
1115 /* Handle overlapping loops correctly */
1116 if (wwo->lpLoopPtr != lpWaveHdr && (lpWaveHdr->dwFlags & WHDR_BEGINLOOP)) {
1117 FIXME("Correctly handled case ? (ending loop buffer also starts a new loop)\n");
1118 /* shall we consider the END flag for the closing loop or for
1119 * the opening one or for both ???
1120 * code assumes for closing loop only
1121 */
1122 } else
1123 {
1124 lpWaveHdr = lpWaveHdr->lpNext;
1125 }
1126 wwo->lpLoopPtr = NULL;
1127 wodHelper_BeginWaveHdr(wwo, lpWaveHdr);
1128 }
1129 } else
1130 {
1131 /* We're not in a loop. Advance to the next wave header */
1132 TRACE("not inside of a loop, advancing to next wave header\n");
1133 wodHelper_BeginWaveHdr(wwo, lpWaveHdr = lpWaveHdr->lpNext);
1134 }
1135
1136 LeaveCriticalSection(&wwo->access_crst);
1137
1138 return lpWaveHdr;
1139 }
1140
1141 /* if force is TRUE then notify the client that all the headers were completed */
1142 static DWORD wodHelper_NotifyCompletions(WINE_WAVEOUT* wwo, BOOL force)
1143 {
1144 LPWAVEHDR lpWaveHdr;
1145 DWORD retval;
1146
1147 TRACE("called\n");
1148
1149 EnterCriticalSection(&wwo->access_crst);
1150
1151 /* Start from lpQueuePtr and keep notifying until:
1152 * - we hit an unwritten wavehdr
1153 * - we hit the beginning of a running loop
1154 * - we hit a wavehdr which hasn't finished playing
1155 */
1156 while ((lpWaveHdr = wwo->lpQueuePtr) &&
1157 (force ||
1158 (lpWaveHdr != wwo->lpPlayPtr &&
1159 lpWaveHdr != wwo->lpLoopPtr)))
1160 {
1161 wwo->lpQueuePtr = lpWaveHdr->lpNext;
1162
1163 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1164 lpWaveHdr->dwFlags |= WHDR_DONE;
1165 TRACE("notifying client: lpWaveHdr=(%p) lpPlayPtr=(%p) dwFlags=(%d)\n",
1166 lpWaveHdr, wwo->lpPlayPtr, lpWaveHdr->dwFlags);
1167
1168 wodNotifyClient(wwo, WOM_DONE, (DWORD_PTR)lpWaveHdr, 0);
1169 }
1170 TRACE("Not notifying client: lpWaveHdr=(%p) lpPlayPtr=(%p) lpLoopPtr=(%p)\n",
1171 lpWaveHdr, wwo->lpPlayPtr, wwo->lpLoopPtr);
1172 retval = (lpWaveHdr && lpWaveHdr != wwo->lpPlayPtr && lpWaveHdr !=
1173 wwo->lpLoopPtr) ? 0 : INFINITE;
1174
1175 LeaveCriticalSection(&wwo->access_crst);
1176
1177 return retval;
1178 }
1179
1180 /**************************************************************************
1181 * wodHelper_Reset [internal]
1182 *
1183 * Resets current output stream.
1184 */
1185 static void wodHelper_Reset(WINE_WAVEOUT* wwo, BOOL reset)
1186 {
1187 EnterCriticalSection(&wwo->access_crst);
1188
1189 /* updates current notify list */
1190 wodHelper_NotifyCompletions(wwo, FALSE);
1191
1192 if (reset)
1193 {
1194 /* remove all wave headers and notify client that all headers were completed */
1195 wodHelper_NotifyCompletions(wwo, TRUE);
1196
1197 wwo->lpPlayPtr = wwo->lpQueuePtr = wwo->lpLoopPtr = NULL;
1198 wwo->state = WINE_WS_STOPPED;
1199 wwo->dwPlayedTotal = wwo->dwWrittenTotal = wwo->bytesInJack = 0;
1200
1201 wwo->dwPartialOffset = 0; /* Clear partial wavehdr */
1202 } else
1203 {
1204 if (wwo->lpLoopPtr)
1205 {
1206 /* complicated case, not handled yet (could imply modifying the loop counter) */
1207 FIXME("Pausing while in loop isn't correctly handled yet, expect strange results\n");
1208 wwo->lpPlayPtr = wwo->lpLoopPtr;
1209 wwo->dwPartialOffset = 0;
1210 wwo->dwWrittenTotal = wwo->dwPlayedTotal; /* this is wrong !!! */
1211 } else
1212 {
1213 LPWAVEHDR ptr;
1214 DWORD sz = wwo->dwPartialOffset;
1215
1216 /* reset all the data as if we had written only up to lpPlayedTotal bytes */
1217 /* compute the max size playable from lpQueuePtr */
1218 for (ptr = wwo->lpQueuePtr; ptr != wwo->lpPlayPtr; ptr = ptr->lpNext)
1219 {
1220 sz += ptr->dwBufferLength;
1221 }
1222
1223 /* because the reset lpPlayPtr will be lpQueuePtr */
1224 if (wwo->dwWrittenTotal > wwo->dwPlayedTotal + sz) ERR("doh\n");
1225 wwo->dwPartialOffset = sz - (wwo->dwWrittenTotal - wwo->dwPlayedTotal);
1226 wwo->dwWrittenTotal = wwo->dwPlayedTotal;
1227 wwo->lpPlayPtr = wwo->lpQueuePtr;
1228 }
1229
1230 wwo->state = WINE_WS_PAUSED;
1231 }
1232
1233 LeaveCriticalSection(&wwo->access_crst);
1234 }
1235
1236 /**************************************************************************
1237 * wodGetDevCaps [internal]
1238 */
1239 static DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPSW lpCaps, DWORD dwSize)
1240 {
1241 TRACE("(%u, %p, %u);\n", wDevID, lpCaps, dwSize);
1242
1243 if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
1244
1245 if (wDevID >= MAX_WAVEOUTDRV)
1246 {
1247 TRACE("MAX_WAVOUTDRV reached !\n");
1248 return MMSYSERR_BADDEVICEID;
1249 }
1250
1251 TRACE("dwSupport=(0x%x), dwFormats=(0x%x)\n", WOutDev[wDevID].caps.dwSupport, WOutDev[wDevID].caps.dwFormats);
1252 memcpy(lpCaps, &WOutDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
1253 return MMSYSERR_NOERROR;
1254 }
1255
1256 /**************************************************************************
1257 * wodOpen [internal]
1258 *
1259 * NOTE: doesn't it seem like there is a race condition if you try to open
1260 * the same device twice?
1261 */
1262 static DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
1263 {
1264 WINE_WAVEOUT* wwo;
1265 DWORD retval;
1266
1267 TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
1268 if (lpDesc == NULL)
1269 {
1270 WARN("Invalid Parameter !\n");
1271 return MMSYSERR_INVALPARAM;
1272 }
1273 if (wDevID >= MAX_WAVEOUTDRV) {
1274 TRACE("MAX_WAVOUTDRV reached !\n");
1275 return MMSYSERR_BADDEVICEID;
1276 }
1277
1278 #if JACK_CLOSE_HACK
1279 if(WOutDev[wDevID].client && WOutDev[wDevID].in_use)
1280 #else
1281 if(WOutDev[wDevID].client)
1282 #endif
1283 {
1284 TRACE("device %d already allocated\n", wDevID);
1285 return MMSYSERR_ALLOCATED;
1286 }
1287
1288 /* Only the PCM format is supported so far...
1289 * Also we only support 16 bit mode.
1290 */
1291 if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
1292 lpDesc->lpFormat->nChannels == 0 ||
1293 lpDesc->lpFormat->nSamplesPerSec == 0 ||
1294 lpDesc->lpFormat->wBitsPerSample != 16)
1295 {
1296 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d wBitsPerSample=%d !\n",
1297 lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1298 lpDesc->lpFormat->nSamplesPerSec, lpDesc->lpFormat->wBitsPerSample);
1299 return WAVERR_BADFORMAT;
1300 }
1301
1302 if (dwFlags & WAVE_FORMAT_QUERY)
1303 {
1304 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
1305 lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
1306 lpDesc->lpFormat->nSamplesPerSec);
1307 return MMSYSERR_NOERROR;
1308 }
1309
1310 wwo = &WOutDev[wDevID];
1311 wwo->wDevID = wDevID;
1312
1313 /* Set things up before we call JACK_OpenWaveOutDevice because */
1314 /* we will start getting callbacks before JACK_OpenWaveOutDevice */
1315 /* even returns and we want to be initialized before then */
1316 wwo->state = WINE_WS_STOPPED; /* start in a stopped state */
1317 wwo->dwPlayedTotal = 0; /* zero out these totals */
1318 wwo->dwWrittenTotal = 0;
1319 wwo->bytesInJack = 0;
1320 wwo->tickCountMS = 0;
1321
1322 /* Initialize volume to full level */
1323 wwo->volume_left = 100;
1324 wwo->volume_right = 100;
1325
1326 InitializeCriticalSection(&wwo->access_crst); /* initialize the critical section */
1327 wwo->access_crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINE_WAVEOUT.access_crst");
1328 EnterCriticalSection(&wwo->access_crst);
1329
1330 dwFlags &= ~WAVE_DIRECTSOUND; /* direct sound not supported, ignore the flag */
1331
1332 wwo->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
1333
1334 wwo->waveDesc = *lpDesc;
1335 memcpy(&wwo->format, lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
1336
1337 /* open up jack ports for this device */
1338 if (!JACK_OpenWaveOutDevice(&WOutDev[wDevID]))
1339 {
1340 ERR("JACK_OpenWaveOutDevice(%d) failed\n", wDevID);
1341 LeaveCriticalSection(&wwo->access_crst);
1342 wwo->access_crst.DebugInfo->Spare[0] = 0;
1343 DeleteCriticalSection(&wwo->access_crst); /* delete the critical section so we can initialize it again from wodOpen() */
1344 return MMSYSERR_ERROR; /* return unspecified error */
1345 }
1346
1347 LeaveCriticalSection(&wwo->access_crst);
1348
1349 /* display the current wave format */
1350 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
1351 wwo->format.wBitsPerSample, wwo->format.wf.nAvgBytesPerSec,
1352 wwo->format.wf.nSamplesPerSec, wwo->format.wf.nChannels,
1353 wwo->format.wf.nBlockAlign);
1354
1355 /* make sure that we have the same sample rate in our audio stream */
1356 /* as we do in the jack server */
1357 if(wwo->format.wf.nSamplesPerSec != wwo->sample_rate)
1358 {
1359 TRACE("error: jack server sample rate is '%ld', wave sample rate is '%d'\n",
1360 wwo->sample_rate, wwo->format.wf.nSamplesPerSec);
1361
1362 #if JACK_CLOSE_HACK
1363 JACK_CloseWaveOutDevice(wwo, FALSE); /* close this device, don't force the client to close */
1364 #else
1365 JACK_CloseWaveOutDevice(wwo); /* close this device */
1366 #endif
1367 wwo->access_crst.DebugInfo->Spare[0] = 0;
1368 DeleteCriticalSection(&wwo->access_crst); /* delete the critical section so we can initialize it again from wodOpen() */
1369 return WAVERR_BADFORMAT;
1370 }
1371
1372 /* check for an invalid number of bits per sample */
1373 if (wwo->format.wBitsPerSample == 0)
1374 {
1375 WARN("Resetting zeroed wBitsPerSample\n");
1376 wwo->format.wBitsPerSample = 8 *
1377 (wwo->format.wf.nAvgBytesPerSec /
1378 wwo->format.wf.nSamplesPerSec) /
1379 wwo->format.wf.nChannels;
1380 }
1381
1382 EnterCriticalSection(&wwo->access_crst);
1383 retval = wodNotifyClient(wwo, WOM_OPEN, 0, 0);
1384 LeaveCriticalSection(&wwo->access_crst);
1385
1386 return retval;
1387 }
1388
1389 /**************************************************************************
1390 * wodClose [internal]
1391 */
1392 static DWORD wodClose(WORD wDevID)
1393 {
1394 DWORD ret = MMSYSERR_NOERROR;
1395 WINE_WAVEOUT* wwo;
1396
1397 TRACE("(%u);\n", wDevID);
1398
1399 if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1400 {
1401 WARN("bad device ID !\n");
1402 return MMSYSERR_BADDEVICEID;
1403 }
1404
1405 wwo = &WOutDev[wDevID];
1406 if (wwo->lpQueuePtr)
1407 {
1408 WARN("buffers still playing !\n");
1409 ret = WAVERR_STILLPLAYING;
1410 } else
1411 {
1412 /* sanity check: this should not happen since the device must have been reset before */
1413 if (wwo->lpQueuePtr || wwo->lpPlayPtr) ERR("out of sync\n");
1414
1415 wwo->state = WINE_WS_CLOSED; /* mark the device as closed */
1416
1417 #if JACK_CLOSE_HACK
1418 JACK_CloseWaveOutDevice(wwo, FALSE); /* close the jack device, DO NOT force the client to close */
1419 #else
1420 JACK_CloseWaveOutDevice(wwo); /* close the jack device */
1421 #endif
1422 wwo->access_crst.DebugInfo->Spare[0] = 0;
1423 DeleteCriticalSection(&wwo->access_crst); /* delete the critical section so we can initialize it again from wodOpen() */
1424
1425 ret = wodNotifyClient(wwo, WOM_CLOSE, 0, 0);
1426 }
1427
1428 return ret;
1429 }
1430
1431
1432 /**************************************************************************
1433 * wodWrite [internal]
1434 *
1435 */
1436 static DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
1437 {
1438 LPWAVEHDR*wh;
1439 WINE_WAVEOUT *wwo;
1440
1441 TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
1442
1443 /* first, do the sanity checks... */
1444 if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1445 {
1446 WARN("bad dev ID !\n");
1447 return MMSYSERR_BADDEVICEID;
1448 }
1449
1450 wwo = &WOutDev[wDevID];
1451
1452 if (lpWaveHdr->lpData == NULL || !(lpWaveHdr->dwFlags & WHDR_PREPARED))
1453 {
1454 TRACE("unprepared\n");
1455 return WAVERR_UNPREPARED;
1456 }
1457
1458 if (lpWaveHdr->dwFlags & WHDR_INQUEUE)
1459 {
1460 TRACE("still playing\n");
1461 return WAVERR_STILLPLAYING;
1462 }
1463
1464 lpWaveHdr->dwFlags &= ~WHDR_DONE;
1465 lpWaveHdr->dwFlags |= WHDR_INQUEUE;
1466 lpWaveHdr->lpNext = 0;
1467
1468 EnterCriticalSection(&wwo->access_crst);
1469
1470 /* insert buffer at the end of queue */
1471 for (wh = &(wwo->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
1472 *wh = lpWaveHdr;
1473
1474 if (!wwo->lpPlayPtr)
1475 wodHelper_BeginWaveHdr(wwo,lpWaveHdr);
1476 if (wwo->state == WINE_WS_STOPPED)
1477 wwo->state = WINE_WS_PLAYING;
1478 LeaveCriticalSection(&wwo->access_crst);
1479
1480 return MMSYSERR_NOERROR;
1481 }
1482
1483 /**************************************************************************
1484 * wodPause [internal]
1485 */
1486 static DWORD wodPause(WORD wDevID)
1487 {
1488 TRACE("(%u);!\n", wDevID);
1489
1490 if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1491 {
1492 WARN("bad device ID !\n");
1493 return MMSYSERR_BADDEVICEID;
1494 }
1495
1496 TRACE("[3-PAUSING]\n");
1497
1498 EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1499 wodHelper_Reset(&WOutDev[wDevID], FALSE);
1500 LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1501
1502 return MMSYSERR_NOERROR;
1503 }
1504
1505 /**************************************************************************
1506 * wodRestart [internal]
1507 */
1508 static DWORD wodRestart(WORD wDevID)
1509 {
1510 TRACE("(%u);\n", wDevID);
1511
1512 if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1513 {
1514 WARN("bad device ID !\n");
1515 return MMSYSERR_BADDEVICEID;
1516 }
1517
1518 if (WOutDev[wDevID].state == WINE_WS_PAUSED)
1519 {
1520 EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1521 WOutDev[wDevID].state = WINE_WS_PLAYING;
1522 LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1523 }
1524
1525 return MMSYSERR_NOERROR;
1526 }
1527
1528 /**************************************************************************
1529 * wodReset [internal]
1530 */
1531 static DWORD wodReset(WORD wDevID)
1532 {
1533 TRACE("(%u);\n", wDevID);
1534
1535 if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1536 {
1537 WARN("bad device ID !\n");
1538 return MMSYSERR_BADDEVICEID;
1539 }
1540
1541 EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1542 wodHelper_Reset(&WOutDev[wDevID], TRUE);
1543 LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1544
1545 return MMSYSERR_NOERROR;
1546 }
1547
1548 /**************************************************************************
1549 * wodGetPosition [internal]
1550 */
1551 static DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
1552 {
1553 DWORD val;
1554 WINE_WAVEOUT* wwo;
1555 DWORD elapsedMS;
1556
1557 TRACE("(%u, %p, %u);\n", wDevID, lpTime, uSize);
1558
1559 if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1560 {
1561 WARN("bad device ID !\n");
1562 return MMSYSERR_BADDEVICEID;
1563 }
1564
1565 /* if null pointer to time structure return error */
1566 if (lpTime == NULL) return MMSYSERR_INVALPARAM;
1567
1568 wwo = &WOutDev[wDevID];
1569
1570 EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1571 val = wwo->dwPlayedTotal;
1572 elapsedMS = GetTickCount() - wwo->tickCountMS;
1573 LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1574
1575 /* account for the bytes played since the last JACK_Callback() */
1576 val+=((elapsedMS * wwo->format.wf.nAvgBytesPerSec) / 1000);
1577
1578 return bytes_to_mmtime(lpTime, val, &wwo->format);
1579 }
1580
1581 /**************************************************************************
1582 * wodBreakLoop [internal]
1583 */
1584 static DWORD wodBreakLoop(WORD wDevID)
1585 {
1586 TRACE("(%u);\n", wDevID);
1587
1588 if (wDevID >= MAX_WAVEOUTDRV || !WOutDev[wDevID].client)
1589 {
1590 WARN("bad device ID !\n");
1591 return MMSYSERR_BADDEVICEID;
1592 }
1593
1594 EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1595
1596 if (WOutDev[wDevID].state == WINE_WS_PLAYING && WOutDev[wDevID].lpLoopPtr != NULL)
1597 {
1598 /* ensure exit at end of current loop */
1599 WOutDev[wDevID].dwLoops = 1;
1600 }
1601
1602 LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1603
1604 return MMSYSERR_NOERROR;
1605 }
1606
1607 /**************************************************************************
1608 * wodGetVolume [internal]
1609 */
1610 static DWORD wodGetVolume(WORD wDevID, LPDWORD lpdwVol)
1611 {
1612 DWORD left, right;
1613
1614 left = WOutDev[wDevID].volume_left;
1615 right = WOutDev[wDevID].volume_right;
1616
1617 TRACE("(%u, %p);\n", wDevID, lpdwVol);
1618
1619 *lpdwVol = ((left * 0xFFFFl) / 100) + (((right * 0xFFFFl) / 100) <<
1620 16);
1621
1622 return MMSYSERR_NOERROR;
1623 }
1624
1625 /**************************************************************************
1626 * wodSetVolume [internal]
1627 */
1628 static DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
1629 {
1630 DWORD left, right;
1631
1632 left = (LOWORD(dwParam) * 100) / 0xFFFFl;
1633 right = (HIWORD(dwParam) * 100) / 0xFFFFl;
1634
1635 TRACE("(%u, %08X);\n", wDevID, dwParam);
1636
1637 EnterCriticalSection(&(WOutDev[wDevID].access_crst));
1638
1639 WOutDev[wDevID].volume_left = left;
1640 WOutDev[wDevID].volume_right = right;
1641
1642 LeaveCriticalSection(&(WOutDev[wDevID].access_crst));
1643
1644 return MMSYSERR_NOERROR;
1645 }
1646
1647 /**************************************************************************
1648 * wodGetNumDevs [internal]
1649 */
1650 static DWORD wodGetNumDevs(void)
1651 {
1652 return MAX_WAVEOUTDRV;
1653 }
1654
1655 /**************************************************************************
1656 * wodDevInterfaceSize [internal]
1657 */
1658 static DWORD wodDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
1659 {
1660 TRACE("(%u, %p)\n", wDevID, dwParam1);
1661
1662 *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1663 NULL, 0 ) * sizeof(WCHAR);
1664 return MMSYSERR_NOERROR;
1665 }
1666
1667 /**************************************************************************
1668 * wodDevInterface [internal]
1669 */
1670 static DWORD wodDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
1671 {
1672 if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1673 NULL, 0 ) * sizeof(WCHAR))
1674 {
1675 MultiByteToWideChar(CP_ACP, 0, WOutDev[wDevID].interface_name, -1,
1676 dwParam1, dwParam2 / sizeof(WCHAR));
1677 return MMSYSERR_NOERROR;
1678 }
1679 return MMSYSERR_INVALPARAM;
1680 }
1681
1682 /**************************************************************************
1683 * wodMessage (WINEJACK.7)
1684 */
1685 DWORD WINAPI JACK_wodMessage(UINT wDevID, UINT wMsg, DWORD dwUser,
1686 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
1687 {
1688 TRACE("(%u, %04X, %08X, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
1689
1690 switch (wMsg) {
1691 case DRVM_INIT:
1692 return JACK_WaveInit();
1693 case DRVM_EXIT:
1694 return JACK_WaveRelease();
1695 case DRVM_ENABLE:
1696 case DRVM_DISABLE:
1697 /* FIXME: Pretend this is supported */
1698 return 0;
1699 case WODM_OPEN: return wodOpen(wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
1700 case WODM_CLOSE: return wodClose(wDevID);
1701 case WODM_WRITE: return wodWrite(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
1702 case WODM_PAUSE: return wodPause(wDevID);
1703 case WODM_GETPOS: return wodGetPosition(wDevID, (LPMMTIME)dwParam1, dwParam2);
1704 case WODM_BREAKLOOP: return wodBreakLoop(wDevID);
1705 case WODM_PREPARE: return MMSYSERR_NOTSUPPORTED;
1706 case WODM_UNPREPARE: return MMSYSERR_NOTSUPPORTED;
1707 case WODM_GETDEVCAPS: return wodGetDevCaps(wDevID, (LPWAVEOUTCAPSW)dwParam1, dwParam2);
1708 case WODM_GETNUMDEVS: return wodGetNumDevs();
1709 case WODM_GETPITCH: return MMSYSERR_NOTSUPPORTED;
1710 case WODM_SETPITCH: return MMSYSERR_NOTSUPPORTED;
1711 case WODM_GETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
1712 case WODM_SETPLAYBACKRATE: return MMSYSERR_NOTSUPPORTED;
1713 case WODM_GETVOLUME: return wodGetVolume(wDevID, (LPDWORD)dwParam1);
1714 case WODM_SETVOLUME: return wodSetVolume(wDevID, dwParam1);
1715 case WODM_RESTART: return wodRestart(wDevID);
1716 case WODM_RESET: return wodReset(wDevID);
1717
1718 case DRV_QUERYDEVICEINTERFACESIZE: return wodDevInterfaceSize (wDevID, (LPDWORD)dwParam1);
1719 case DRV_QUERYDEVICEINTERFACE: return wodDevInterface (wDevID, (PWCHAR)dwParam1, dwParam2);
1720 case DRV_QUERYDSOUNDIFACE: return wodDsCreate(wDevID, (PIDSDRIVER*)dwParam1);
1721 case DRV_QUERYDSOUNDDESC: return wodDsDesc(wDevID, (PDSDRIVERDESC)dwParam1);
1722 default:
1723 FIXME("unknown message %d!\n", wMsg);
1724 }
1725 return MMSYSERR_NOTSUPPORTED;
1726 }
1727
1728 /*======================================================================*
1729 * Low level DSOUND implementation *
1730 *======================================================================*/
1731
1732 typedef struct IDsDriverImpl IDsDriverImpl;
1733 typedef struct IDsDriverBufferImpl IDsDriverBufferImpl;
1734
1735 struct IDsDriverImpl
1736 {
1737 /* IUnknown fields */
1738 const IDsDriverVtbl *lpVtbl;
1739 DWORD ref;
1740 /* IDsDriverImpl fields */
1741 UINT wDevID;
1742 IDsDriverBufferImpl*primary;
1743 };
1744
1745 struct IDsDriverBufferImpl
1746 {
1747 /* IUnknown fields */
1748 const IDsDriverBufferVtbl *lpVtbl;
1749 DWORD ref;
1750 /* IDsDriverBufferImpl fields */
1751 IDsDriverImpl* drv;
1752 DWORD buflen;
1753 };
1754
1755 static DWORD wodDsCreate(UINT wDevID, PIDSDRIVER* drv)
1756 {
1757 /* we can't perform memory mapping as we don't have a file stream
1758 interface with jack like we do with oss */
1759 MESSAGE("This sound card's driver does not support direct access\n");
1760 MESSAGE("The (slower) DirectSound HEL mode will be used instead.\n");
1761 return MMSYSERR_NOTSUPPORTED;
1762 }
1763
1764 static DWORD wodDsDesc(UINT wDevID, PDSDRIVERDESC desc)
1765 {
1766 memset(desc, 0, sizeof(*desc));
1767 strcpy(desc->szDesc, "Wine jack DirectSound Driver");
1768 strcpy(desc->szDrvname, "winejack.drv");
1769 return MMSYSERR_NOERROR;
1770 }
1771
1772 /*======================================================================*
1773 * Low level WAVE IN implementation *
1774 *======================================================================*/
1775
1776 /**************************************************************************
1777 * widNotifyClient [internal]
1778 */
1779 static DWORD widNotifyClient(WINE_WAVEIN* wwi, WORD wMsg, DWORD_PTR dwParam1,
1780 DWORD_PTR dwParam2)
1781 {
1782 TRACE("wMsg = %04X dwParm1 = %08lX dwParam2 = %08lX\n", wMsg, dwParam1, dwParam2);
1783
1784 switch (wMsg) {
1785 case WIM_OPEN:
1786 case WIM_CLOSE:
1787 case WIM_DATA:
1788 if (wwi->wFlags != DCB_NULL &&
1789 !DriverCallback(wwi->waveDesc.dwCallback, wwi->wFlags,
1790 (HDRVR)wwi->waveDesc.hWave, wMsg, wwi->waveDesc.dwInstance,
1791 dwParam1, dwParam2))
1792 {
1793 WARN("can't notify client !\n");
1794 return MMSYSERR_ERROR;
1795 }
1796 break;
1797 default:
1798 FIXME("Unknown callback message %u\n", wMsg);
1799 return MMSYSERR_INVALPARAM;
1800 }
1801 return MMSYSERR_NOERROR;
1802 }
1803
1804 /******************************************************************
1805 * JACK_callback_wwi
1806 */
1807 /* everytime the jack server wants something from us it calls this
1808 function */
1809 static int JACK_callback_wwi (nframes_t nframes, void *arg)
1810 {
1811 sample_t* in_l;
1812 sample_t* in_r = 0;
1813 WINE_WAVEIN* wwi = arg;
1814
1815 TRACE("wDevID: %u, nframes %u\n", wwi->wDevID, nframes);
1816
1817 if(!wwi->client)
1818 ERR("client is closed, this is weird...\n");
1819
1820 in_l = fp_jack_port_get_buffer(wwi->in_port_l, nframes);
1821
1822 if (wwi->in_port_r)
1823 in_r = fp_jack_port_get_buffer(wwi->in_port_r, nframes);
1824
1825 EnterCriticalSection(&wwi->access_crst);
1826
1827 if((wwi->lpQueuePtr != NULL) && (wwi->state == WINE_WS_PLAYING))
1828 {
1829 LPWAVEHDR lpWaveHdr = wwi->lpQueuePtr;
1830 nframes_t jackFramesLeft = nframes;
1831
1832 #if JACK_CLOSE_HACK
1833 if(wwi->in_use == FALSE)
1834 {
1835 /* do nothing if nothing is being recorded */
1836 LeaveCriticalSection(&wwi->access_crst);
1837 return 0;
1838 }
1839 #endif
1840
1841 TRACE("wwi.state == WINE_WS_PLAYING\n");
1842
1843 while (lpWaveHdr && jackFramesLeft)
1844 {
1845 DWORD waveHdrFramesLeft = (lpWaveHdr->dwBufferLength - lpWaveHdr->dwBytesRecorded) / (sizeof(short) * wwi->format.wf.nChannels);
1846 DWORD numFrames = min (jackFramesLeft, waveHdrFramesLeft);
1847
1848 TRACE ("dwBufferLength=(%u) dwBytesRecorded=(%d)\n", lpWaveHdr->dwBufferLength, lpWaveHdr->dwBytesRecorded);
1849 TRACE ("jackFramesLeft=(%u) waveHdrFramesLeft=(%u)\n", jackFramesLeft, waveHdrFramesLeft);
1850
1851 if (!in_r) {
1852 /* mono */
1853 sample_move_s16_d16((short *)((char *)lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded), in_l+(nframes-jackFramesLeft), numFrames, 1);
1854 } else {
1855 /* stereo */
1856 sample_move_s16_d16((short *)((char *)lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded),
1857 in_l+(nframes-jackFramesLeft), numFrames, 2);
1858 sample_move_s16_d16((short *)((char *)lpWaveHdr->lpData + lpWaveHdr->dwBytesRecorded + sizeof(short)),
1859 in_r+(nframes-jackFramesLeft), numFrames, 2);
1860 }
1861
1862 lpWaveHdr->dwBytesRecorded += (numFrames * sizeof(short) * wwi->format.wf.nChannels );
1863 jackFramesLeft -= numFrames;
1864
1865 if (lpWaveHdr->dwBytesRecorded >= lpWaveHdr->dwBufferLength)
1866 {
1867 /* must copy the value of next waveHdr, because we have no idea of what
1868 * will be done with the content of lpWaveHdr in callback
1869 */
1870 LPWAVEHDR lpNext = lpWaveHdr->lpNext;
1871
1872 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
1873 lpWaveHdr->dwFlags |= WHDR_DONE;
1874
1875 TRACE("WaveHdr full. dwBytesRecorded=(%u) dwFlags=(0x%x)\n",lpWaveHdr->dwBytesRecorded,lpWaveHdr->dwFlags);
1876
1877 widNotifyClient(wwi, WIM_DATA, (DWORD_PTR)lpWaveHdr, 0);
1878
1879 lpWaveHdr = wwi->lpQueuePtr = lpNext;
1880 }
1881 }
1882 TRACE ("jackFramesLeft=(%u) lpWaveHdr=(%p)\n", jackFramesLeft, lpWaveHdr);
1883 if (jackFramesLeft > 0) { WARN("Record buffer ran out of WaveHdrs\n"); }
1884 }
1885
1886 LeaveCriticalSection(&wwi->access_crst);
1887
1888 return 0;
1889 }
1890
1891 /******************************************************************
1892 * JACK_OpenWaveInDevice
1893 */
1894 static int JACK_OpenWaveInDevice(WINE_WAVEIN* wwi, WORD nChannels)
1895 {
1896 const char** ports;
1897 int i;
1898 char client_name[64];
1899 jack_port_t* in_port_l;
1900 jack_port_t* in_port_r = 0;
1901 jack_client_t* client;
1902 int failed = 0;
1903
1904 TRACE("creating jack client and setting up callbacks\n");
1905
1906 if ((nChannels == 0) || (nChannels > 2)) {
1907 ERR ("nChannels = (%d), but we only support mono or stereo.\n", nChannels);
1908 return 0;
1909 }
1910
1911 #if JACK_CLOSE_HACK
1912 /* see if this device is already open */
1913 if(wwi->client)
1914 {
1915 /* if this device is already in use then it is bad for us to be in here */
1916 if(wwi->in_use)
1917 return 0;
1918
1919 TRACE("using existing client\n");
1920 wwi->in_use = TRUE;
1921 return 1;
1922 }
1923 #endif
1924
1925 /* zero out the buffer pointer and the size of the buffer */
1926 wwi->sound_buffer = 0;
1927 wwi->buffer_size = 0;
1928
1929 /* try to become a client of the JACK server */
1930 snprintf(client_name, sizeof(client_name), "wine_jack_in_%d", wwi->wDevID);
1931 TRACE("client name '%s'\n", client_name);
1932 if ((client = fp_jack_client_open (client_name, JackUseExactName, NULL)) == 0)
1933 {
1934 /* jack has problems with shutting down clients, so lets */
1935 /* wait a short while and try once more before we give up */
1936 Sleep(250);
1937 if ((client = fp_jack_client_open (client_name, JackUseExactName, NULL)) == 0)
1938 {
1939 ERR("jack server not running?\n");
1940 return 0;
1941 }
1942 }
1943 wwi->client = client;
1944
1945 /* tell the JACK server to call `JACK_wwi_callback()' whenever
1946 there is work to be done. */
1947 fp_jack_set_process_callback (client, JACK_callback_wwi, wwi);
1948
1949 /* tell the JACK server to call `JACK_bufsize_wwi()' whenever
1950 the maximum number of frames that will be passed
1951 to `JACK_Callback()' changes */
1952 fp_jack_set_buffer_size_callback (client, JACK_bufsize_wwi, wwi);
1953
1954 /* tell the JACK server to call `srate()' whenever
1955 the sample rate of the system changes. */
1956 fp_jack_set_sample_rate_callback (client, JACK_srate, wwi);
1957
1958 /* tell the JACK server to call `jack_shutdown()' if
1959 it ever shuts down, either entirely, or if it
1960 just decides to stop calling us. */
1961 fp_jack_on_shutdown (client, JACK_shutdown_wwi, wwi);
1962
1963 /* display the current sample rate. once the client is activated
1964 (see below), you should rely on your own sample rate
1965 callback (see above) for this value. */
1966 wwi->sample_rate = fp_jack_get_sample_rate(client);
1967 TRACE("engine sample rate: %lu\n", wwi->sample_rate);
1968
1969 /* create the left and right channel output ports */
1970 /* jack's ports are all mono so for stereo you need two */
1971 in_port_l = fp_jack_port_register (client, "in_l",
1972 JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1973 wwi->in_port_l = in_port_l;
1974 TRACE("Created port. (%p)\n", in_port_l);
1975
1976 if (nChannels == 2)
1977 {
1978 in_port_r = fp_jack_port_register (client, "in_r",
1979 JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
1980 TRACE("Created port. (%p)\n", in_port_r);
1981 }
1982 wwi->in_port_r = in_port_r;
1983
1984 #if JACK_CLOSE_HACK
1985 wwi->in_use = TRUE; /* mark this device as in use since it now is ;-) */
1986 #endif
1987
1988 TRACE("activating client.\n");
1989 /* tell the JACK server that we are ready to roll */
1990 if (fp_jack_activate (client))
1991 {
1992 ERR( "cannot activate client\n");
1993 return 0;
1994 }
1995 TRACE("activated client.\n");
1996 /* figure out what the ports that we want to output on are */
1997 /* NOTE: we do this instead of using stuff like "alsa_pcm:playback_X" because */
1998 /* this way works if names are changed */
1999 ports = fp_jack_get_ports(client, NULL, NULL, JackPortIsPhysical|JackPortIsOutput);
2000
2001 /* display a trace of the output ports we found */
2002 for(i = 0; ports[i]; i++)
2003 {
2004 TRACE("ports[%d] = '%s'\n", i, ports[i]);
2005 }
2006
2007 if(!ports)
2008 {
2009 ERR("jack_get_ports() failed to find 'JackPortIsPhysical|JackPortIsOutput'\n");
2010 }
2011
2012 /* connect the ports. Note: you can't do this before
2013 the client is activated (this may change in the future).
2014 */
2015 /* we want to connect to two ports so we have stereo input ;-) */
2016
2017 if(fp_jack_connect(client, ports[0], fp_jack_port_name(in_port_l)))
2018 {
2019 ERR ("cannot connect to input port %d('%s')\n", 0, ports[0]);
2020 failed = 1;
2021 }
2022 TRACE("Connected (%s)<->(%s)\n",ports[0],fp_jack_port_name(in_port_l));
2023
2024 if ((nChannels == 2) && in_port_r) {
2025 if(fp_jack_connect(client, ports[1], fp_jack_port_name(in_port_r)))
2026 {
2027 ERR ("cannot connect to input port %d('%s')\n", 1, ports[1]);
2028 failed = 1;
2029 }
2030 TRACE("Connected (%s)<->(%s)\n",ports[1],fp_jack_port_name(in_port_r));
2031 }
2032 free(ports); /* free the returned array of ports */
2033
2034 /* if something failed we need to shut the client down and return 0 */
2035 if(failed)
2036 {
2037 #if JACK_CLOSE_HACK
2038 JACK_CloseWaveInDevice(wwi, TRUE);
2039 #else
2040 JACK_CloseWaveInDevice(wwi);
2041 #endif
2042 return 0;
2043 }
2044
2045 TRACE("return success.\n");
2046 return 1; /* return success */
2047 }
2048
2049 /**************************************************************************
2050 * widGetDevCaps [internal]
2051 */
2052 static DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPSW lpCaps, DWORD dwSize)
2053 {
2054 TRACE("(%u, %p, %u);\n", wDevID, lpCaps, dwSize);
2055
2056 if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
2057
2058 if (wDevID >= MAX_WAVEINDRV) {
2059 TRACE("MAX_WAVEINDRV reached !\n");
2060 return MMSYSERR_BADDEVICEID;
2061 }
2062
2063 memcpy(lpCaps, &WInDev[wDevID].caps, min(dwSize, sizeof(*lpCaps)));
2064 return MMSYSERR_NOERROR;
2065 }
2066
2067 /**************************************************************************
2068 * widOpen [internal]
2069 */
2070 static DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
2071 {
2072 WINE_WAVEIN* wwi;
2073 DWORD retval;
2074
2075 TRACE("(%u, %p, %08X);\n", wDevID, lpDesc, dwFlags);
2076 if (lpDesc == NULL)
2077 {
2078 WARN("Invalid Parameter !\n");
2079 return MMSYSERR_INVALPARAM;
2080 }
2081 if (wDevID >= MAX_WAVEINDRV) {
2082 TRACE ("MAX_WAVEINDRV reached !\n");
2083 return MMSYSERR_BADDEVICEID;
2084 }
2085
2086 #if JACK_CLOSE_HACK
2087 if(WInDev[wDevID].client && WOutDev[wDevID].in_use)
2088 #else
2089 if(WInDev[wDevID].client)
2090 #endif
2091 {
2092 TRACE("device %d already allocated\n", wDevID);
2093 return MMSYSERR_ALLOCATED;
2094 }
2095
2096 /* Only the PCM format is supported so far...
2097 * Also we only support 16 bit mode.
2098 */
2099 if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM ||
2100 lpDesc->lpFormat->nChannels == 0 ||
2101 lpDesc->lpFormat->nSamplesPerSec == 0 ||
2102 lpDesc->lpFormat->wBitsPerSample!=16)
2103 {
2104 WARN("Bad format: tag=%04X nChannels=%d nSamplesPerSec=%d wBitsPerSample=%d !\n",
2105 lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
2106 lpDesc->lpFormat->nSamplesPerSec, lpDesc->lpFormat->wBitsPerSample);
2107 return WAVERR_BADFORMAT;
2108 }
2109
2110 if (dwFlags & WAVE_FORMAT_QUERY)
2111 {
2112 TRACE("Query format: tag=%04X nChannels=%d nSamplesPerSec=%d !\n",
2113 lpDesc->lpFormat->wFormatTag, lpDesc->lpFormat->nChannels,
2114 lpDesc->lpFormat->nSamplesPerSec);
2115 return MMSYSERR_NOERROR;
2116 }
2117
2118 wwi = &WInDev[wDevID];
2119 wwi->wDevID = wDevID;
2120
2121 /* Set things up before we call JACK_OpenWaveOutDevice because */
2122 /* we will start getting callbacks before JACK_OpenWaveOutDevice */
2123 /* even returns and we want to be initialized before then */
2124 wwi->state = WINE_WS_STOPPED; /* start in a stopped state */
2125
2126 InitializeCriticalSection(&wwi->access_crst); /* initialize the critical section */
2127 wwi->access_crst.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": WINE_WAVEIN.access_crst");
2128 EnterCriticalSection(&wwi->access_crst);
2129
2130 /* open up jack ports for this device */
2131 if (!JACK_OpenWaveInDevice(&WInDev[wDevID], lpDesc->lpFormat->nChannels))
2132 {
2133 ERR("JACK_OpenWaveInDevice(%d) failed\n", wDevID);
2134 LeaveCriticalSection(&wwi->access_crst);
2135 wwi->access_crst.DebugInfo->Spare[0] = 0;
2136 DeleteCriticalSection(&wwi->access_crst);
2137 return MMSYSERR_ERROR; /* return unspecified error */
2138 }
2139
2140 dwFlags &= ~WAVE_DIRECTSOUND; /* direct sound not supported, ignore the flag */
2141
2142 wwi->wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
2143
2144 wwi->waveDesc = *lpDesc;
2145 memcpy(&wwi->format, lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
2146
2147 LeaveCriticalSection(&wwi->access_crst);
2148
2149 /* display the current wave format */
2150 TRACE("wBitsPerSample=%u, nAvgBytesPerSec=%u, nSamplesPerSec=%u, nChannels=%u nBlockAlign=%u!\n",
2151 wwi->format.wBitsPerSample, wwi->format.wf.nAvgBytesPerSec,
2152 wwi->format.wf.nSamplesPerSec, wwi->format.wf.nChannels,
2153 wwi->format.wf.nBlockAlign);
2154
2155 /* make sure that we have the same sample rate in our audio stream */
2156 /* as we do in the jack server */
2157 if(wwi->format.wf.nSamplesPerSec != wwi->sample_rate)
2158 {
2159 TRACE("error: jack server sample rate is '%ld', wave sample rate is '%d'\n",
2160 wwi->sample_rate, wwi->format.wf.nSamplesPerSec);
2161
2162 #if JACK_CLOSE_HACK
2163 JACK_CloseWaveInDevice(wwi, FALSE); /* close this device, don't force the client to close */
2164 #else
2165 JACK_CloseWaveInDevice(wwi); /* close this device */
2166 #endif
2167 wwi->access_crst.DebugInfo->Spare[0] = 0;
2168 DeleteCriticalSection(&wwi->access_crst);
2169 return WAVERR_BADFORMAT;
2170 }
2171
2172 /* check for an invalid number of bits per sample */
2173 if (wwi->format.wBitsPerSample == 0)
2174 {
2175 WARN("Resetting zeroed wBitsPerSample\n");
2176 wwi->format.wBitsPerSample = 8 *
2177 (wwi->format.wf.nAvgBytesPerSec /
2178 wwi->format.wf.nSamplesPerSec) /
2179 wwi->format.wf.nChannels;
2180 }
2181
2182 TRACE("notify client.\n");
2183 EnterCriticalSection(&wwi->access_crst);
2184 retval = widNotifyClient(wwi, WIM_OPEN, 0, 0);
2185 LeaveCriticalSection(&wwi->access_crst);
2186
2187 return retval;
2188 }
2189 /**************************************************************************
2190 * widClose [internal]
2191 */
2192 static DWORD widClose(WORD wDevID)
2193 {
2194 DWORD ret = MMSYSERR_NOERROR;
2195 WINE_WAVEIN* wwi;
2196
2197 TRACE("(%u);\n", wDevID);
2198
2199 if (wDevID >= MAX_WAVEINDRV || !WInDev[wDevID].client)
2200 {
2201 WARN("bad device ID !\n");
2202 return MMSYSERR_BADDEVICEID;
2203 }
2204
2205 wwi = &WInDev[wDevID];
2206 if (wwi->lpQueuePtr)
2207 {
2208 WARN("buffers still playing !\n");
2209 ret = WAVERR_STILLPLAYING;
2210 } else
2211 {
2212 /* sanity check: this should not happen since the device must have been reset before */
2213 if (wwi->lpQueuePtr) ERR("out of sync\n");
2214
2215 wwi->state = WINE_WS_CLOSED; /* mark the device as closed */
2216
2217 #if JACK_CLOSE_HACK
2218 JACK_CloseWaveInDevice(wwi, FALSE); /* close the jack device, DO NOT force the client to close */
2219 #else
2220 JACK_CloseWaveInDevice(wwi); /* close the jack device */
2221 #endif
2222 wwi->access_crst.DebugInfo->Spare[0] = 0;
2223 DeleteCriticalSection(&wwi->access_crst); /* delete the critical section so we can initialize it again from wodOpen() */
2224
2225 ret = widNotifyClient(wwi, WIM_CLOSE, 0, 0);
2226 }
2227
2228 return ret;
2229 }
2230
2231 /**************************************************************************
2232 * widAddBuffer [internal]
2233 */
2234 static DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
2235 {
2236 WINE_WAVEIN* wwi = &WInDev[wDevID];
2237
2238 TRACE("(%u, %p, %08X);\n", wDevID, lpWaveHdr, dwSize);
2239
2240 if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2241 WARN("can't do it !\n");
2242 return MMSYSERR_INVALHANDLE;
2243 }
2244 if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) {
2245 TRACE("never been prepared !\n");
2246 return WAVERR_UNPREPARED;
2247 }
2248 if (lpWaveHdr->dwFlags & WHDR_INQUEUE) {
2249 TRACE("header already in use !\n");
2250 return WAVERR_STILLPLAYING;
2251 }
2252
2253 lpWaveHdr->dwFlags |= WHDR_INQUEUE;
2254 lpWaveHdr->dwFlags &= ~WHDR_DONE;
2255 lpWaveHdr->dwBytesRecorded = 0;
2256 lpWaveHdr->lpNext = NULL;
2257
2258 EnterCriticalSection(&wwi->access_crst);
2259 /* insert buffer at end of queue */
2260 {
2261 LPWAVEHDR* wh;
2262 for (wh = &(wwi->lpQueuePtr); *wh; wh = &((*wh)->lpNext));
2263 *wh=lpWaveHdr;
2264 }
2265 LeaveCriticalSection(&wwi->access_crst);
2266
2267 return MMSYSERR_NOERROR;
2268 }
2269
2270 /**************************************************************************
2271 * widStart [internal]
2272 */
2273 static DWORD widStart(WORD wDevID)
2274 {
2275 TRACE("(%u);\n", wDevID);
2276 if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2277 WARN("can't start recording !\n");
2278 return MMSYSERR_INVALHANDLE;
2279 }
2280
2281 WInDev[wDevID].state = WINE_WS_PLAYING;
2282 return MMSYSERR_NOERROR;
2283 }
2284
2285 /**************************************************************************
2286 * widStop [internal]
2287 */
2288 static DWORD widStop(WORD wDevID)
2289 {
2290 WINE_WAVEIN* wwi = &WInDev[wDevID];
2291
2292 TRACE("(%u);\n", wDevID);
2293 if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2294 WARN("can't stop !\n");
2295 return MMSYSERR_INVALHANDLE;
2296 }
2297
2298 if (wwi->state != WINE_WS_STOPPED)
2299 {
2300 WAVEHDR* lpWaveHdr;
2301 /* do something here to stop recording ??? */
2302
2303 /* return current buffer to app */
2304 lpWaveHdr = wwi->lpQueuePtr;
2305 if (lpWaveHdr)
2306 {
2307 LPWAVEHDR lpNext = lpWaveHdr->lpNext;
2308 TRACE("stop %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
2309 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2310 lpWaveHdr->dwFlags |= WHDR_DONE;
2311 widNotifyClient(wwi, WIM_DATA, (DWORD_PTR)lpWaveHdr, 0);
2312 wwi->lpQueuePtr = lpNext;
2313 }
2314 }
2315 wwi->state = WINE_WS_STOPPED;
2316
2317 return MMSYSERR_NOERROR;
2318 }
2319
2320 /**************************************************************************
2321 * widReset [internal]
2322 */
2323 static DWORD widReset(WORD wDevID)
2324 {
2325 WINE_WAVEIN* wwi = &WInDev[wDevID];
2326 WAVEHDR* lpWaveHdr;
2327
2328 TRACE("(%u);\n", wDevID);
2329 if (wDevID >= MAX_WAVEINDRV || WInDev[wDevID].state == WINE_WS_CLOSED) {
2330 WARN("can't reset !\n");
2331 return MMSYSERR_INVALHANDLE;
2332 }
2333
2334 wwi->state = WINE_WS_STOPPED;
2335
2336 /* return all buffers to the app */
2337 for (lpWaveHdr = wwi->lpQueuePtr; lpWaveHdr; lpWaveHdr = lpWaveHdr->lpNext) {
2338 TRACE("reset %p %p\n", lpWaveHdr, lpWaveHdr->lpNext);
2339 lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
2340 lpWaveHdr->dwFlags |= WHDR_DONE;
2341
2342 widNotifyClient(wwi, WIM_DATA, (DWORD_PTR)lpWaveHdr, 0);
2343 }
2344 wwi->lpQueuePtr = NULL;
2345
2346 return MMSYSERR_NOERROR;
2347 }
2348
2349 /**************************************************************************
2350 * widGetNumDevs [internal]
2351 */
2352 static DWORD widGetNumDevs(void)
2353 {
2354 return MAX_WAVEINDRV;
2355 }
2356
2357 /**************************************************************************
2358 * widDevInterfaceSize [internal]
2359 */
2360 static DWORD widDevInterfaceSize(UINT wDevID, LPDWORD dwParam1)
2361 {
2362 TRACE("(%u, %p)\n", wDevID, dwParam1);
2363
2364
2365 *dwParam1 = MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2366 NULL, 0 ) * sizeof(WCHAR);
2367 return MMSYSERR_NOERROR;
2368 }
2369
2370 /**************************************************************************
2371 * widDevInterface [internal]
2372 */
2373 static DWORD widDevInterface(UINT wDevID, PWCHAR dwParam1, DWORD dwParam2)
2374 {
2375 if (dwParam2 >= MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2376 NULL, 0 ) * sizeof(WCHAR))
2377 {
2378 MultiByteToWideChar(CP_ACP, 0, WInDev[wDevID].interface_name, -1,
2379 dwParam1, dwParam2 / sizeof(WCHAR));
2380 return MMSYSERR_NOERROR;
2381 }
2382 return MMSYSERR_INVALPARAM;
2383 }
2384
2385 /**************************************************************************
2386 * widMessage (WINEJACK.6)
2387 */
2388 DWORD WINAPI JACK_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2389 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2390 {
2391 TRACE("(%u, %04X, %08X, %08lX, %08lX);\n", wDevID, wMsg, dwUser, dwParam1, dwParam2);
2392
2393 switch (wMsg) {
2394 case DRVM_INIT:
2395 return JACK_WaveInit();
2396 case DRVM_EXIT:
2397 return JACK_WaveRelease();
2398 case DRVM_ENABLE:
2399 case DRVM_DISABLE:
2400 /* FIXME: Pretend this is supported */
2401 return 0;
2402 case WIDM_OPEN: return widOpen (wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
2403 case WIDM_CLOSE: return widClose (wDevID);
2404 case WIDM_ADDBUFFER: return widAddBuffer (wDevID, (LPWAVEHDR)dwParam1, dwParam2);
2405 case WIDM_PREPARE: return MMSYSERR_NOTSUPPORTED;
2406 case WIDM_UNPREPARE: return MMSYSERR_NOTSUPPORTED;
2407 case WIDM_GETDEVCAPS: return widGetDevCaps (wDevID, (LPWAVEINCAPSW)dwParam1, dwParam2);
2408 case WIDM_GETNUMDEVS: return widGetNumDevs();
2409 case WIDM_RESET: return widReset (wDevID);
2410 case WIDM_START: return widStart (wDevID);
2411 case WIDM_STOP: return widStop (wDevID);
2412 case DRV_QUERYDEVICEINTERFACESIZE: return widDevInterfaceSize (wDevID, (LPDWORD)dwParam1);
2413 case DRV_QUERYDEVICEINTERFACE: return widDevInterface (wDevID, (PWCHAR)dwParam1, dwParam2);
2414 default:
2415 FIXME("unknown message %d!\n", wMsg);
2416 }
2417
2418 return MMSYSERR_NOTSUPPORTED;
2419 }
2420
2421 #else /* !SONAME_LIBJACK */
2422
2423 /**************************************************************************
2424 * widMessage (WINEJACK.6)
2425 */
2426 DWORD WINAPI JACK_widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2427 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2428 {
2429 FIXME("(%u, %04X, %08X, %08lX, %08lX):jack support not compiled into wine\n",
2430 wDevID, wMsg, dwUser, dwParam1, dwParam2);
2431 return MMSYSERR_NOTENABLED;
2432 }
2433
2434 /**************************************************************************
2435 * wodMessage (WINEJACK.7)
2436 */
2437 DWORD WINAPI JACK_wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
2438 DWORD_PTR dwParam1, DWORD_PTR dwParam2)
2439 {
2440 FIXME("(%u, %04X, %08X, %08lX, %08lX):jack support not compiled into wine\n",
2441 wDevID, wMsg, dwUser, dwParam1, dwParam2);
2442 return MMSYSERR_NOTENABLED;
2443 }
2444
2445 #endif /* SONAME_LIBJACK */
useful hacks and other patches not (yet) suitable for mainline