Release 940706
Sun, 3 Jul 1994 20:15:56 +0100 (BST) David Metcalfe <david@prism.demon.co.uk>
* [controls/edit.c]
Bug fixes and tidying up. Preliminary tab stop support
(doesn't work yet).
* [windows/dialog.c]
Reversed order of buttons in CheckRadioButtons so that all
buttons are now displayed.
Tue Jul 5 18:30:24 1994 Alexandre Julliard (julliard@lamisun.epfl.ch)
* [include/options.h] [misc/main.c] [windows/win.c]
Removed nosaveunders option, replaced by handling
the CS_SAVEBITS flag.
* [windows/class.c]
Modified the fix for negative size in class extra bytes to
avoid modifying the caller's data.
* [windows/dc.c]
Bug fix: system font must be a proportional font.
Fixed a bug that caused the default pen to not be selected
correctly in a DC.
* [windows/graphics.c]
Bug fix in GRAPH_DrawArc(). Thanks to Adriano Azevedo for
noticing it.
* [windows/painting.c]
Removed incorrect selecting of default objects in BeginPaint()
(no longer needed because of the fix in dc.c).
Jul 4, 94 martin2@trgcorp.solucorp.qc.ca (Martin Ayotte)
* [misc/mmsystem.c]
* [misc/audio.c]
Add more code to interface '/dev/dsp'.
* New file [misc/mcicda.c]
Create an MCI_DEVTYPE_CD_AUDIO driver connected to '/dev/sbpcd'.
* New file [misc/mmaux.c]
Stubs to make a future driver connected to '/dev/mixer'.
* [windows/win.c]
Temporary patch to CreateWindowEx() for reseting negative
coordinates to 0,0 ; because 'soundrec.exe' give negative values
and I need it to work on MMSYSTEM ... :-)
* [miscemu/int2f.c]
add a stub 'do_int2f_16' (function 0x16) for DMPI server.
Mon Jun 20 10:08:40 BST 1994 William Smith (wos@dcs.warwick.ac.uk)
* include/comm.h
New file -- some definitions that were in comm.c now need to
be shared with misc/dos_fs.c
* misc/comm.c
Some definitions moved into include/comm.h
* misc/dos_fs.c (DOS_GetEquipment):
Fixed error in equipment -- bitwise or of two values should
be used instead of logical or. Also added code to correctly
report the number of serial and parallel devices.
diff --git a/ChangeLog b/ChangeLog
index 0e61684..adcba41 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,72 @@
----------------------------------------------------------------------
+Sun, 3 Jul 1994 20:15:56 +0100 (BST) David Metcalfe <david@prism.demon.co.uk>
+
+ * [controls/edit.c]
+ Bug fixes and tidying up. Preliminary tab stop support
+ (doesn't work yet).
+
+ * [windows/dialog.c]
+ Reversed order of buttons in CheckRadioButtons so that all
+ buttons are now displayed.
+
+Tue Jul 5 18:30:24 1994 Alexandre Julliard (julliard@lamisun.epfl.ch)
+
+ * [include/options.h] [misc/main.c] [windows/win.c]
+ Removed nosaveunders option, replaced by handling
+ the CS_SAVEBITS flag.
+
+ * [windows/class.c]
+ Modified the fix for negative size in class extra bytes to
+ avoid modifying the caller's data.
+
+ * [windows/dc.c]
+ Bug fix: system font must be a proportional font.
+ Fixed a bug that caused the default pen to not be selected
+ correctly in a DC.
+
+ * [windows/graphics.c]
+ Bug fix in GRAPH_DrawArc(). Thanks to Adriano Azevedo for
+ noticing it.
+
+ * [windows/painting.c]
+ Removed incorrect selecting of default objects in BeginPaint()
+ (no longer needed because of the fix in dc.c).
+
+Jul 4, 94 martin2@trgcorp.solucorp.qc.ca (Martin Ayotte)
+
+ * [misc/mmsystem.c]
+ * [misc/audio.c]
+ Add more code to interface '/dev/dsp'.
+
+ * New file [misc/mcicda.c]
+ Create an MCI_DEVTYPE_CD_AUDIO driver connected to '/dev/sbpcd'.
+
+ * New file [misc/mmaux.c]
+ Stubs to make a future driver connected to '/dev/mixer'.
+
+ * [windows/win.c]
+ Temporary patch to CreateWindowEx() for reseting negative
+ coordinates to 0,0 ; because 'soundrec.exe' give negative values
+ and I need it to work on MMSYSTEM ... :-)
+
+ * [miscemu/int2f.c]
+ add a stub 'do_int2f_16' (function 0x16) for DMPI server.
+
+Mon Jun 20 10:08:40 BST 1994 William Smith (wos@dcs.warwick.ac.uk)
+
+ * include/comm.h
+ New file -- some definitions that were in comm.c now need to
+ be shared with misc/dos_fs.c
+
+ * misc/comm.c
+ Some definitions moved into include/comm.h
+
+ * misc/dos_fs.c (DOS_GetEquipment):
+ Fixed error in equipment -- bitwise or of two values should
+ be used instead of logical or. Also added code to correctly
+ report the number of serial and parallel devices.
+
+----------------------------------------------------------------------
Mon Jun 20 14:26:41 1994 Bob Amstadt (bob@pooh)
* [objects/bitmap.c]
diff --git a/controls/edit.c b/controls/edit.c
index 3aff8f8..2a1c12c 100644
--- a/controls/edit.c
+++ b/controls/edit.c
@@ -67,6 +67,8 @@
int DeletedLength; /* length of deleted text */
int DeletedCurrLine; /* starting line from which text was deleted */
int DeletedCurrCol; /* starting col from which text was deleted */
+ int NumTabStops; /* number of tab stops in buffer hTabStops */
+ HANDLE hTabStops; /* handle of tab stops buffer */
} EDITSTATE;
@@ -79,6 +81,9 @@
#define CurrChar (EDIT_TextLine(hwnd, es->CurrLine) + es->CurrCol)
#define SelMarked(es) (es->SelBegLine != 0 || es->SelBegCol != 0 || \
es->SelEndLine != 0 || es->SelEndCol != 0)
+#define ROUNDUP(numer, denom) ((numer % denom) \
+ ? (((numer + denom) / denom) * denom) \
+ : numer)
/* macros to access window styles */
#define IsAutoVScroll() (wndPtr->dwStyle & ES_AUTOVSCROLL)
@@ -104,14 +109,16 @@
void EDIT_PaintMsg(HWND hwnd);
HANDLE EDIT_GetTextLine(HWND hwnd, int selection);
char *EDIT_TextLine(HWND hwnd, int sel);
-int EDIT_LineLength(EDITSTATE *es, char *str, int len);
+int EDIT_StrLength(EDITSTATE *es, char *str, int len, int pcol);
+int EDIT_LineLength(HWND hwnd, int num);
void EDIT_WriteTextLine(HWND hwnd, RECT *rc, int y);
void EDIT_WriteText(HWND hwnd, char *lp, int off, int len, int row,
int col, RECT *rc, BOOL blank, BOOL reverse);
HANDLE EDIT_GetStr(EDITSTATE *es, char *lp, int off, int len, int *diff);
void EDIT_CharMsg(HWND hwnd, WORD wParam);
void EDIT_KeyTyped(HWND hwnd, short ch);
-int EDIT_CharWidth(EDITSTATE *es, short ch);
+int EDIT_CharWidth(EDITSTATE *es, short ch, int pcol);
+int EDIT_GetNextTabStop(EDITSTATE *es, int pcol);
void EDIT_Forward(HWND hwnd);
void EDIT_Downward(HWND hwnd);
void EDIT_Upward(HWND hwnd);
@@ -162,6 +169,7 @@
void *EDIT_TextAddr(EDITSTATE *es, unsigned int handle);
unsigned int EDIT_TextReAlloc(EDITSTATE *es, unsigned int handle, int bytes);
void EDIT_SetHandleMsg(HWND hwnd, WORD wParam);
+LONG EDIT_SetTabStopsMsg(HWND hwnd, WORD wParam, LONG lParam);
void swap(int *a, int *b);
@@ -295,7 +303,7 @@
break;
case EM_SETTABSTOPS:
- printf("edit: cannot process EM_SETTABSTOPS message\n");
+ lResult = EDIT_SetTabStopsMsg(hwnd, wParam, lParam);
break;
case EM_SETWORDBREAKPROC:
@@ -451,7 +459,7 @@
/* --- text buffer */
es->localheap = &HEAP_LocalFindHeap(createStruct->hInstance)->free_list;
es->MaxTextLen = MAXTEXTLEN + 1;
- if (!(es->hText))
+ if (!(createStruct->lpszName))
{
es->textlen = EditBufLen(wndPtr) + 1;
es->hText = EDIT_TextAlloc(es, EditBufLen(wndPtr) + 2);
@@ -464,15 +472,18 @@
if (strlen(createStruct->lpszName) < EditBufLen(wndPtr))
{
es->hText = EDIT_TextAlloc(es, EditBufLen(wndPtr) + 2);
- es->textlen = EditBufLen(wndPtr) + 1;
+ text = EDIT_TextAddr(es, es->hText);
+ strcpy(text, createStruct->lpszName);
*(text + es->textlen) = '\0';
+ es->textlen = EditBufLen(wndPtr) + 1;
}
else
{
es->hText = EDIT_TextAlloc(es, strlen(createStruct->lpszName) + 2);
+ text = EDIT_TextAddr(es, es->hText);
+ strcpy(text, createStruct->lpszName);
es->textlen = strlen(createStruct->lpszName) + 1;
}
- text = EDIT_TextAddr(es, es->hText);
*(text + es->textlen + 1) = '\0';
EDIT_BuildTextPointers(hwnd);
}
@@ -524,6 +535,8 @@
es->hFont = 0;
es->hDeletedText = 0;
es->DeletedLength = 0;
+ es->NumTabStops = 0;
+ es->hTabStops = EDIT_HEAP_ALLOC(sizeof(int));
/* allocate space for a line full of blanks to speed up */
/* line filling */
@@ -608,14 +621,15 @@
/* advance through current line */
while (*cp && *cp != '\n')
{
- len += charWidths[*cp]; /* width of line in pixels */
+ len += EDIT_CharWidth(es, *cp, len); /* width of line in pixels */
cp++;
}
es->textwidth = max(es->textwidth, len);
if (*cp)
cp++; /* skip '\n' */
}
- off = (unsigned int)(cp - text); /* offset of beginning of line */
+
+ off = (unsigned int)(cp - text);
*(textPtrs + es->wlines) = off;
}
@@ -722,27 +736,46 @@
/*********************************************************************
- * EDIT_LineLength
+ * EDIT_StrLength
*
- * Return length of line _str_ of length _len_ characters in pixels.
+ * Return length of string _str_ of length _len_ characters in pixels.
+ * The current column offset in pixels _pcol_ is required to calculate
+ * the width of a tab.
*/
-int EDIT_LineLength(EDITSTATE *es, char *str, int len)
+int EDIT_StrLength(EDITSTATE *es, char *str, int len, int pcol)
{
int i, plen = 0;
- short *charWidths = (short *)EDIT_HEAP_ADDR(es->hCharWidths);
for (i = 0; i < len; i++)
- plen += charWidths[*(str + i)];
+ plen += EDIT_CharWidth(es, *(str + i), pcol + plen);
#ifdef DEBUG_EDIT
- printf("EDIT_LineLength: returning %d\n", plen);
+ printf("EDIT_StrLength: returning %d\n", plen);
#endif
return plen;
}
/*********************************************************************
+ * EDIT_LineLength
+ *
+ * Return length of line _num_ in characters.
+ */
+
+int EDIT_LineLength(HWND hwnd, int num)
+{
+ WND *wndPtr = WIN_FindWndPtr(hwnd);
+ EDITSTATE *es = (EDITSTATE *)EDIT_HEAP_ADDR((HANDLE)(*(wndPtr->wExtra)));
+ char *cp = EDIT_TextLine(hwnd, num);
+ char *cp1;
+
+ cp1 = strchr(cp, '\n');
+ return cp1 ? (int)(cp1 - cp) : strlen(cp);
+}
+
+
+/*********************************************************************
* EDIT_WriteTextLine
*
* Write the line of text at offset _y_ in text buffer to a window.
@@ -812,7 +845,7 @@
if ((hLine = EDIT_GetTextLine(hwnd, y)) == 0)
return;
lp = (unsigned char *)EDIT_HEAP_ADDR(hLine);
- lnlen = EDIT_LineLength(es, lp, strlen(lp));
+ lnlen = EDIT_StrLength(es, lp, strlen(lp), 0);
lnlen1 = lnlen;
/* build the line to display */
@@ -852,7 +885,7 @@
TRUE, TRUE);
else if (y == sbl)
{
- col = EDIT_LineLength(es, lp, sbc);
+ col = EDIT_StrLength(es, lp, sbc, 0);
if (col > (es->wleft + rc.left))
{
len = min(col - off, rc.right - off);
@@ -862,7 +895,7 @@
}
if (y == sel)
{
- col = EDIT_LineLength(es, lp, sec);
+ col = EDIT_StrLength(es, lp, sec, 0);
if (col < (es->wleft + rc.right))
{
len = min(col - off, rc.right - off);
@@ -890,7 +923,7 @@
}
else if (y == sel)
{
- col = EDIT_LineLength(es, lp, sec);
+ col = EDIT_StrLength(es, lp, sec, 0);
if (col < (es->wleft + rc.right))
{
len = min(col - off, rc.right - off);
@@ -930,14 +963,15 @@
{
HDC hdc;
HANDLE hStr;
- char *str, *blanks;
- int diff, num_spaces;
+ char *str, *cp, *cp1;
+ int diff, num_spaces, tabwidth, scol;
HRGN hrgnClip;
COLORREF oldTextColor, oldBkgdColor;
HFONT oldfont;
WND *wndPtr = WIN_FindWndPtr(hwnd);
EDITSTATE *es = (EDITSTATE *)EDIT_HEAP_ADDR((HANDLE)(*(wndPtr->wExtra)));
short *charWidths = (short *)EDIT_HEAP_ADDR(es->hCharWidths);
+ char *blanks = (char *)EDIT_HEAP_ADDR(es->hBlankLine);
#ifdef DEBUG_EDIT
printf("EDIT_WriteText lp=%s, off=%d, len=%d, row=%d, col=%d, reverse=%d\n", lp, off, len, row, col, reverse);
@@ -963,7 +997,31 @@
SetTextColor(hdc, oldBkgdColor);
}
- TextOut(hdc, col - diff, row * es->txtht, str, strlen(str));
+ if (!(cp = strchr(str, VK_TAB)))
+ TextOut(hdc, col - diff, row * es->txtht, str, strlen(str));
+ else
+ {
+ TextOut(hdc, col - diff, row * es->txtht, str, (int)(cp - str));
+ scol = EDIT_StrLength(es, str, (int)(cp - str), 0);
+ tabwidth = EDIT_CharWidth(es, VK_TAB, scol);
+ num_spaces = tabwidth / charWidths[32] + 1;
+ TextOut(hdc, scol, row * es->txtht, blanks, num_spaces);
+ cp++;
+ scol += tabwidth;
+
+ while (cp1 = strchr(cp, VK_TAB))
+ {
+ TextOut(hdc, scol, row * es->txtht, cp, (int)(cp1 - cp));
+ scol = EDIT_StrLength(es, cp, (int)(cp1 - cp), scol);
+ tabwidth = EDIT_CharWidth(es, VK_TAB, scol);
+ num_spaces = tabwidth / charWidths[32] + 1;
+ TextOut(hdc, scol, row * es->txtht, blanks, num_spaces);
+ cp = ++cp1;
+ scol += tabwidth;
+ }
+
+ TextOut(hdc, scol, row * es->txtht, cp, strlen(cp));
+ }
if (reverse)
{
@@ -976,7 +1034,6 @@
{
if ((rc->right - col) > len)
{
- blanks = EDIT_HEAP_ADDR(es->hBlankLine);
num_spaces = (rc->right - col - len) / charWidths[32];
TextOut(hdc, col + len, row * es->txtht, blanks, num_spaces);
}
@@ -1003,9 +1060,8 @@
{
HANDLE hStr;
char *str;
- int ch = 0, i = 0, j, tmp;
+ int ch = 0, i = 0, j, s_i;
int ch1;
- short *charWidths = (short *)EDIT_HEAP_ADDR(es->hCharWidths);
#ifdef DEBUG_EDIT
printf("EDIT_GetStr %s %d %d\n", lp, off, len);
@@ -1013,19 +1069,23 @@
while (i < off)
{
- i += charWidths[*(lp + ch)];
+ s_i = i;
+ i += EDIT_CharWidth(es, *(lp + ch), i);
ch++;
}
/* if stepped past _off_, go back a character */
if (i - off)
- i -= charWidths[*(lp + --ch)];
+ {
+ i = s_i;
+ ch--;
+ }
*diff = off - i;
ch1 = ch;
while (i < len + off)
{
- i += charWidths[*(lp + ch)];
+ i += EDIT_CharWidth(es, *(lp + ch), i);
ch++;
}
@@ -1102,7 +1162,7 @@
return;
}
- if (*currchar == '\0')
+ if (*currchar == '\0' && IsMultiLine())
{
/* insert a newline at end of text */
*currchar = '\n';
@@ -1145,13 +1205,13 @@
if (IsMultiLine() && es->wlines > 1)
{
es->textwidth = max(es->textwidth,
- EDIT_LineLength(es, EDIT_TextLine(hwnd, es->CurrLine),
+ EDIT_StrLength(es, EDIT_TextLine(hwnd, es->CurrLine),
(int)(EDIT_TextLine(hwnd, es->CurrLine + 1) -
- EDIT_TextLine(hwnd, es->CurrLine))));
+ EDIT_TextLine(hwnd, es->CurrLine)), 0));
}
else
es->textwidth = max(es->textwidth,
- EDIT_LineLength(es, text, strlen(text)));
+ EDIT_StrLength(es, text, strlen(text), 0));
EDIT_WriteTextLine(hwnd, NULL, es->wtop + es->WndRow);
if (ch == '\n')
@@ -1177,14 +1237,15 @@
}
/* test end of window */
- if (es->WndCol >= ClientWidth(wndPtr) - EDIT_CharWidth(es, ch))
+ if (es->WndCol >= ClientWidth(wndPtr) -
+ EDIT_CharWidth(es, ch, es->WndCol + es->wleft))
{
/* TODO:- Word wrap to be handled here */
/* if (!(currchar == text + es->MaxTextLen - 2)) */
EDIT_KeyHScroll(hwnd, SB_LINEDOWN);
}
- es->WndCol += EDIT_CharWidth(es, ch);
+ es->WndCol += EDIT_CharWidth(es, ch, es->WndCol + es->wleft);
es->CurrCol++;
SetCaretPos(es->WndCol, es->WndRow * es->txtht);
ShowCaret(hwnd);
@@ -1196,13 +1257,46 @@
* EDIT_CharWidth
*
* Return the width of the given character in pixels.
+ * The current column offset in pixels _pcol_ is required to calculate
+ * the width of a tab.
*/
-int EDIT_CharWidth(EDITSTATE *es, short ch)
+int EDIT_CharWidth(EDITSTATE *es, short ch, int pcol)
{
short *charWidths = (short *)EDIT_HEAP_ADDR(es->hCharWidths);
- return (charWidths[ch]);
+ if (ch != VK_TAB)
+ return (charWidths[ch]);
+ else
+ return (EDIT_GetNextTabStop(es, pcol) - pcol);
+}
+
+
+/*********************************************************************
+ * EDIT_GetNextTabStop
+ *
+ * Return the next tab stop beyond _pcol_.
+ */
+
+int EDIT_GetNextTabStop(EDITSTATE *es, int pcol)
+{
+ int i;
+ int baseUnitWidth = LOWORD(GetDialogBaseUnits());
+ unsigned short *tabstops = EDIT_HEAP_ADDR(es->hTabStops);
+
+ if (es->NumTabStops == 0)
+ return ROUNDUP(pcol, 8);
+ else if (es->NumTabStops == 1)
+ return ROUNDUP(pcol, *tabstops * baseUnitWidth / 4);
+ else
+ {
+ for (i = 0; i < es->NumTabStops; i++)
+ {
+ if (*(tabstops + i) * baseUnitWidth / 4 >= pcol)
+ return (*(tabstops + i) * baseUnitWidth / 4);
+ }
+ return pcol;
+ }
}
@@ -1217,9 +1311,8 @@
WND *wndPtr = WIN_FindWndPtr(hwnd);
EDITSTATE *es = (EDITSTATE *)EDIT_HEAP_ADDR((HANDLE)(*(wndPtr->wExtra)));
char *text = EDIT_TextAddr(es, es->hText);
- char *cc = CurrChar + 1;
- if (*cc == '\0')
+ if (*CurrChar == '\0')
return;
if (*CurrChar == '\n')
@@ -1229,7 +1322,7 @@
}
else
{
- es->WndCol += EDIT_CharWidth(es, *CurrChar);
+ es->WndCol += EDIT_CharWidth(es, *CurrChar, es->WndCol + es->wleft);
es->CurrCol++;
if (es->WndCol >= ClientWidth(wndPtr))
EDIT_KeyHScroll(hwnd, SB_LINEDOWN);
@@ -1309,7 +1402,7 @@
if (es->CurrCol)
{
--es->CurrCol;
- es->WndCol -= EDIT_CharWidth(es, *CurrChar);
+ es->WndCol -= EDIT_CharWidth(es, *CurrChar, es->WndCol + es->wleft);
if (es->WndCol < 0)
EDIT_KeyHScroll(hwnd, SB_LINEUP);
}
@@ -1336,7 +1429,7 @@
while (*CurrChar && *CurrChar != '\n')
{
- es->WndCol += EDIT_CharWidth(es, *CurrChar);
+ es->WndCol += EDIT_CharWidth(es, *CurrChar, es->WndCol + es->wleft);
es->CurrCol++;
}
@@ -1382,15 +1475,13 @@
{
WND *wndPtr = WIN_FindWndPtr(hwnd);
EDITSTATE *es = (EDITSTATE *)EDIT_HEAP_ADDR((HANDLE)(*(wndPtr->wExtra)));
+ int len = EDIT_LineLength(hwnd, es->CurrLine);
+ char *cp = EDIT_TextLine(hwnd, es->CurrLine);
char currpel;
- char *cp = EDIT_TextLine(hwnd, es->CurrLine);
- char *cp1 = strchr(cp, '\n');
- int len = cp1 ? (int)(cp1 - cp) : 0;
-
es->CurrCol = min(len, es->CurrCol);
- es->WndCol = min(EDIT_LineLength(es, cp, len) - es->wleft, es->WndCol);
- currpel = EDIT_LineLength(es, cp, es->CurrCol);
+ es->WndCol = min(EDIT_StrLength(es, cp, len, 0) - es->wleft, es->WndCol);
+ currpel = EDIT_StrLength(es, cp, es->CurrCol, 0);
if (es->wleft > currpel)
{
@@ -1848,7 +1939,6 @@
if (es->wtop + ClientHeight(wndPtr, es) >= es->wlines)
return;
es->wtop++;
- printf("Scroll line down: wtop=%d\n", es->wtop);
}
else
{
@@ -1856,7 +1946,6 @@
if (es->wtop == 0)
return;
--es->wtop;
- printf("Scroll line up: wtop=%d\n", es->wtop);
}
if (IsWindowVisible(hwnd))
@@ -1974,7 +2063,7 @@
void EDIT_LButtonDownMsg(HWND hwnd, WORD wParam, LONG lParam)
{
- char *cp, *cp1;
+ char *cp;
int len;
BOOL end = FALSE;
WND *wndPtr = WIN_FindWndPtr(hwnd);
@@ -1995,12 +2084,10 @@
es->CurrLine = es->wtop + es->WndRow;
cp = EDIT_TextLine(hwnd, es->CurrLine);
- cp1 = strchr(cp, '\n');
- len = cp1 ? (int)(cp1 - cp) : 0;
-
+ len = EDIT_LineLength(hwnd, es->CurrLine);
es->WndCol = LOWORD(lParam);
- if (es->WndCol > EDIT_LineLength(es, cp, len) - es->wleft || end)
- es->WndCol = EDIT_LineLength(es, cp, len) - es->wleft;
+ if (es->WndCol > EDIT_StrLength(es, cp, len, 0) - es->wleft || end)
+ es->WndCol = EDIT_StrLength(es, cp, len, 0) - es->wleft;
es->CurrCol = EDIT_PixelToChar(hwnd, es->CurrLine, &(es->WndCol));
ButtonDown = TRUE;
@@ -2040,11 +2127,10 @@
int EDIT_PixelToChar(HWND hwnd, int row, int *pixel)
{
- int ch = 0, i = 0;
+ int ch = 0, i = 0, s_i;
char *text;
WND *wndPtr = WIN_FindWndPtr(hwnd);
EDITSTATE *es = (EDITSTATE *)EDIT_HEAP_ADDR((HANDLE)(*(wndPtr->wExtra)));
- short *charWidths = (short *)EDIT_HEAP_ADDR(es->hCharWidths);
#ifdef DEBUG_EDIT
printf("EDIT_PixelToChar: row=%d, pixel=%d\n", row, *pixel);
@@ -2053,13 +2139,17 @@
text = EDIT_TextLine(hwnd, row);
while (i < *pixel)
{
- i += charWidths[*(text + ch)];
+ s_i = i;
+ i += EDIT_CharWidth(es, *(text + ch), i);
ch++;
}
/* if stepped past _pixel_, go back a character */
if (i - *pixel)
- i -= charWidths[*(text + ch)];
+ {
+ i = s_i;
+ --ch;
+ }
*pixel = i;
return ch;
}
@@ -2154,8 +2244,8 @@
es->wtop = es->SelEndLine;
es->WndRow = 0;
}
- es->WndCol = EDIT_LineLength(es, EDIT_TextLine(hwnd, es->SelEndLine),
- es->SelEndCol) - es->wleft;
+ es->WndCol = EDIT_StrLength(es, EDIT_TextLine(hwnd, es->SelEndLine),
+ es->SelEndCol, 0) - es->wleft;
}
InvalidateRect(hwnd, NULL, TRUE);
UpdateWindow(hwnd);
@@ -2202,8 +2292,10 @@
}
*line = lineno - 1;
*col = off - (int)(cp1 - text);
+#if 0
if (*(text + *col) == '\0')
(*col)--;
+#endif
}
@@ -2238,8 +2330,8 @@
es->wtop = es->SelBegLine;
es->WndRow = 0;
}
- es->WndCol = EDIT_LineLength(es, bbl - es->SelBegCol,
- es->SelBegCol) - es->wleft;
+ es->WndCol = EDIT_StrLength(es, bbl - es->SelBegCol,
+ es->SelBegCol, 0) - es->wleft;
EDIT_BuildTextPointers(hwnd);
es->PaintBkgd = TRUE;
@@ -2329,7 +2421,7 @@
void EDIT_ExtendSel(HWND hwnd, int x, int y)
{
int bbl, bel, bbc, bec;
- char *cp, *cp1;
+ char *cp;
int len;
BOOL end = FALSE;
WND *wndPtr = WIN_FindWndPtr(hwnd);
@@ -2342,8 +2434,7 @@
bbl = es->SelEndLine;
bbc = es->SelEndCol;
cp = EDIT_TextLine(hwnd, es->wtop + y / es->txtht);
- cp1 = strchr(cp, '\n');
- len = cp1 ? (int)(cp1 - cp) : 0;
+ len = EDIT_LineLength(hwnd, es->wtop + y / es->txtht);
es->WndRow = y / es->txtht;
if (es->WndRow > es->wlines - es->wtop - 1)
@@ -2358,8 +2449,8 @@
es->SelEndLine = es->CurrLine;
es->WndCol = x;
- if (es->WndCol > EDIT_LineLength(es, cp, len) - es->wleft || end)
- es->WndCol = EDIT_LineLength(es, cp, len) - es->wleft;
+ if (es->WndCol > EDIT_StrLength(es, cp, len, 0) - es->wleft || end)
+ es->WndCol = EDIT_StrLength(es, cp, len, 0) - es->wleft;
es->CurrCol = EDIT_PixelToChar(hwnd, es->CurrLine, &(es->WndCol));
es->SelEndCol = es->CurrCol - 1;
@@ -2404,7 +2495,7 @@
{
RECT rc;
int scol, ecol;
- char *cp, *cp1;
+ char *cp;
HDC hdc;
HBRUSH hbrush, holdbrush;
int olddm;
@@ -2425,15 +2516,12 @@
/* get length of line if end == -1 */
if (end == -1)
- {
- cp1 = strchr(cp, '\n');
- end = cp1 ? (int)(cp1 - cp) : 0;
- }
+ end = EDIT_LineLength(hwnd, y);
- scol = EDIT_LineLength(es, cp, start);
+ scol = EDIT_StrLength(es, cp, start, 0);
if (scol > rc.right) return;
if (scol < rc.left) scol = rc.left;
- ecol = EDIT_LineLength(es, cp, end);
+ ecol = EDIT_StrLength(es, cp, end, 0);
if (ecol < rc.left) return;
if (ecol > rc.right) ecol = rc.right;
@@ -2551,8 +2639,8 @@
EDIT_GetLineCol(hwnd, (int)((CurrChar + len) - text), &(es->CurrLine),
&(es->CurrCol));
es->WndRow = es->CurrLine - es->wtop;
- es->WndCol = EDIT_LineLength(es, EDIT_TextLine(hwnd, es->CurrLine),
- es->CurrCol) - es->wleft;
+ es->WndCol = EDIT_StrLength(es, EDIT_TextLine(hwnd, es->CurrLine),
+ es->CurrCol, 0) - es->wleft;
}
@@ -2669,8 +2757,8 @@
ReleaseDC(hwnd, hdc);
es->WndRow = (es->CurrLine - es->wtop) / es->txtht;
- es->WndCol = EDIT_LineLength(es, EDIT_TextLine(hwnd, es->CurrLine),
- es->CurrCol) - es->wleft;
+ es->WndCol = EDIT_StrLength(es, EDIT_TextLine(hwnd, es->CurrLine),
+ es->CurrCol, 0) - es->wleft;
InvalidateRect(hwnd, NULL, TRUE);
es->PaintBkgd = TRUE;
@@ -2741,8 +2829,8 @@
EDIT_GetLineCol(hwnd, (int)((CurrChar + es->DeletedLength) - text),
&(es->CurrLine), &(es->CurrCol));
es->WndRow = es->CurrLine - es->wtop;
- es->WndCol = EDIT_LineLength(es, EDIT_TextLine(hwnd, es->CurrLine),
- es->CurrCol) - es->wleft;
+ es->WndCol = EDIT_StrLength(es, EDIT_TextLine(hwnd, es->CurrLine),
+ es->CurrCol, 0) - es->wleft;
es->SelEndLine = es->CurrLine;
es->SelEndCol = es->CurrCol;
@@ -2826,6 +2914,35 @@
/*********************************************************************
+ * EM_SETTABSTOPS message function
+ */
+
+LONG EDIT_SetTabStopsMsg(HWND hwnd, WORD wParam, LONG lParam)
+{
+ unsigned short *tabstops;
+ WND *wndPtr = WIN_FindWndPtr(hwnd);
+ EDITSTATE *es = (EDITSTATE *)EDIT_HEAP_ADDR((HANDLE)(*(wndPtr->wExtra)));
+
+ es->NumTabStops = wParam;
+ if (wParam == 0)
+ es->hTabStops = EDIT_HEAP_REALLOC(es->hTabStops, 1);
+ else if (wParam == 1)
+ {
+ es->hTabStops = EDIT_HEAP_REALLOC(es->hTabStops, 1);
+ tabstops = (unsigned short *)EDIT_HEAP_ADDR(es->hTabStops);
+ *tabstops = (unsigned short)lParam;
+ }
+ else
+ {
+ es->hTabStops = EDIT_HEAP_REALLOC(es->hTabStops, wParam);
+ tabstops = (unsigned short *)EDIT_HEAP_ADDR(es->hTabStops);
+ memcpy(tabstops, (unsigned short *)lParam, wParam);
+ }
+ return 0L;
+}
+
+
+/*********************************************************************
* Utility functions
*/
diff --git a/controls/listbox.c b/controls/listbox.c
index 196cb9b..8b7af56 100644
--- a/controls/listbox.c
+++ b/controls/listbox.c
@@ -1151,7 +1151,7 @@
{
if (DOS_ValidDrive(x))
{
- sprintf(temp, "[-%c-]", 'A'+x);
+ sprintf(temp, "[-%c-]", 'a'+x);
if ( (wRet = ListBoxAddString(hwnd, temp)) == LB_ERR)
break;
}
diff --git a/include/comm.h b/include/comm.h
new file mode 100644
index 0000000..7f74685
--- /dev/null
+++ b/include/comm.h
@@ -0,0 +1,21 @@
+/*
+ * Communications header
+ *
+ * 93 Erik Bos (erik@trashcan.hacktic.nl)
+ */
+
+#ifndef COMM_H
+#define COMM_H
+
+
+#define MAX_PORTS 16
+
+struct DosDeviceStruct {
+ char *devicename; /* /dev/cua1 */
+ int fd;
+ int suspended;
+ int unget;
+ int unget_byte;
+};
+
+#endif /* COMM_H */
diff --git a/include/mmsystem.h b/include/mmsystem.h
index de39b93..feb2eda 100644
--- a/include/mmsystem.h
+++ b/include/mmsystem.h
@@ -8,6 +8,11 @@
typedef LPSTR HPSTR; /* a huge version of LPSTR */
typedef LPCSTR HPCSTR; /* a huge version of LPCSTR */
+#define MAXWAVEDRIVERS 10
+#define MAXMIDIDRIVERS 10
+#define MAXAUXDRIVERS 10
+#define MAXMCIDRIVERS 32
+
#define MAXPNAMELEN 32 /* max product name length (including NULL) */
#define MAXERRORLENGTH 128 /* max error text length (including NULL) */
@@ -166,7 +171,7 @@
#define WAVE_FORMAT_QUERY 0x0001
#define WAVE_ALLOWSYNC 0x0002
-typedef struct {
+typedef struct wavehdr_tag {
LPSTR lpData; /* pointer to locked data buffer */
DWORD dwBufferLength; /* length of data buffer */
DWORD dwBytesRecorded; /* used for input only */
@@ -764,8 +769,10 @@
#define MCIERR_CUSTOM_DRIVER_BASE (MCIERR_BASE + 256)
-#define MCI_OPEN 0x0803
-#define MCI_CLOSE 0x0804
+#define MCI_OPEN_DRIVER 0x0801
+#define MCI_CLOSE_DRIVER 0x0802
+#define MCI_OPEN 0x0803
+#define MCI_CLOSE 0x0804
#define MCI_ESCAPE 0x0805
#define MCI_PLAY 0x0806
#define MCI_SEEK 0x0807
@@ -1389,6 +1396,126 @@
* Linux MMSYSTEM Internals & Sample Audio Drivers
*/
+#define DRVM_INIT 100
+#define WODM_INIT DRVM_INIT
+#define WIDM_INIT DRVM_INIT
+#define MODM_INIT DRVM_INIT
+#define MIDM_INIT DRVM_INIT
+#define AUXM_INIT DRVM_INIT
+
+#define WODM_GETNUMDEVS 3
+#define WODM_GETDEVCAPS 4
+#define WODM_OPEN 5
+#define WODM_CLOSE 6
+#define WODM_PREPARE 7
+#define WODM_UNPREPARE 8
+#define WODM_WRITE 9
+#define WODM_PAUSE 10
+#define WODM_RESTART 11
+#define WODM_RESET 12
+#define WODM_GETPOS 13
+#define WODM_GETPITCH 14
+#define WODM_SETPITCH 15
+#define WODM_GETVOLUME 16
+#define WODM_SETVOLUME 17
+#define WODM_GETPLAYBACKRATE 18
+#define WODM_SETPLAYBACKRATE 19
+#define WODM_BREAKLOOP 20
+
+#define WIDM_GETNUMDEVS 50
+#define WIDM_GETDEVCAPS 51
+#define WIDM_OPEN 52
+#define WIDM_CLOSE 53
+#define WIDM_PREPARE 54
+#define WIDM_UNPREPARE 55
+#define WIDM_ADDBUFFER 56
+#define WIDM_START 57
+#define WIDM_STOP 58
+#define WIDM_RESET 59
+#define WIDM_GETPOS 60
+
+#define MODM_GETNUMDEVS 1
+#define MODM_GETDEVCAPS 2
+#define MODM_OPEN 3
+#define MODM_CLOSE 4
+#define MODM_PREPARE 5
+#define MODM_UNPREPARE 6
+#define MODM_DATA 7
+#define MODM_LONGDATA 8
+#define MODM_RESET 9
+#define MODM_GETVOLUME 10
+#define MODM_SETVOLUME 11
+#define MODM_CACHEPATCHES 12
+#define MODM_CACHEDRUMPATCHES 13
+
+#define MIDM_GETNUMDEVS 53
+#define MIDM_GETDEVCAPS 54
+#define MIDM_OPEN 55
+#define MIDM_CLOSE 56
+#define MIDM_PREPARE 57
+#define MIDM_UNPREPARE 58
+#define MIDM_ADDBUFFER 59
+#define MIDM_START 60
+#define MIDM_STOP 61
+#define MIDM_RESET 62
+
+#define AUXDM_GETNUMDEVS 3
+#define AUXDM_GETDEVCAPS 4
+#define AUXDM_GETVOLUME 5
+#define AUXDM_SETVOLUME 6
+
+#define MCI_MAX_DEVICE_TYPE_LENGTH 80
+
+#define MCI_FALSE (MCI_STRING_OFFSET + 19)
+#define MCI_TRUE (MCI_STRING_OFFSET + 20)
+
+#define MCI_FORMAT_RETURN_BASE MCI_FORMAT_MILLISECONDS_S
+#define MCI_FORMAT_MILLISECONDS_S (MCI_STRING_OFFSET + 21)
+#define MCI_FORMAT_HMS_S (MCI_STRING_OFFSET + 22)
+#define MCI_FORMAT_MSF_S (MCI_STRING_OFFSET + 23)
+#define MCI_FORMAT_FRAMES_S (MCI_STRING_OFFSET + 24)
+#define MCI_FORMAT_SMPTE_24_S (MCI_STRING_OFFSET + 25)
+#define MCI_FORMAT_SMPTE_25_S (MCI_STRING_OFFSET + 26)
+#define MCI_FORMAT_SMPTE_30_S (MCI_STRING_OFFSET + 27)
+#define MCI_FORMAT_SMPTE_30DROP_S (MCI_STRING_OFFSET + 28)
+#define MCI_FORMAT_BYTES_S (MCI_STRING_OFFSET + 29)
+#define MCI_FORMAT_SAMPLES_S (MCI_STRING_OFFSET + 30)
+#define MCI_FORMAT_TMSF_S (MCI_STRING_OFFSET + 31)
+
+#define MCI_VD_FORMAT_TRACK_S (MCI_VD_OFFSET + 5)
+
+#define WAVE_FORMAT_PCM_S (MCI_WAVE_OFFSET + 0)
+#define WAVE_MAPPER_S (MCI_WAVE_OFFSET + 1)
+
+#define MCI_SEQ_MAPPER_S (MCI_SEQ_OFFSET + 5)
+#define MCI_SEQ_FILE_S (MCI_SEQ_OFFSET + 6)
+#define MCI_SEQ_MIDI_S (MCI_SEQ_OFFSET + 7)
+#define MCI_SEQ_SMPTE_S (MCI_SEQ_OFFSET + 8)
+#define MCI_SEQ_FORMAT_SONGPTR_S (MCI_SEQ_OFFSET + 9)
+#define MCI_SEQ_NONE_S (MCI_SEQ_OFFSET + 10)
+#define MIDIMAPPER_S (MCI_SEQ_OFFSET + 11)
+
+#define MCI_RESOURCE_RETURNED 0x00010000 /* resource ID */
+#define MCI_COLONIZED3_RETURN 0x00020000 /* colonized ID, 3 bytes data */
+#define MCI_COLONIZED4_RETURN 0x00040000 /* colonized ID, 4 bytes data */
+#define MCI_INTEGER_RETURNED 0x00080000 /* integer conversion needed */
+#define MCI_RESOURCE_DRIVER 0x00100000 /* driver owns returned resource */
+
+#define MCI_NO_COMMAND_TABLE 0xFFFF
+
+#define MCI_COMMAND_HEAD 0
+#define MCI_STRING 1
+#define MCI_INTEGER 2
+#define MCI_END_COMMAND 3
+#define MCI_RETURN 4
+#define MCI_FLAG 5
+#define MCI_END_COMMAND_LIST 6
+#define MCI_RECT 7
+#define MCI_CONSTANT 8
+#define MCI_END_CONSTANT 9
+
+#define MAKEMCIRESOURCE(wRet, wRes) MAKELRESULT((wRet), (wRes))
+
typedef struct {
DWORD dwCallback;
DWORD dwInstance;
@@ -1397,6 +1524,56 @@
} PORTALLOC;
typedef PORTALLOC FAR *LPPORTALLOC;
+typedef struct {
+ HWAVE hWave;
+ LPWAVEFORMAT lpFormat;
+ DWORD dwCallBack;
+ DWORD dwInstance;
+ } WAVEOPENDESC;
+typedef WAVEOPENDESC FAR *LPWAVEOPENDESC;
+
+typedef struct {
+ HMIDI hMidi;
+ DWORD dwCallback;
+ DWORD dwInstance;
+ } MIDIOPENDESC;
+typedef MIDIOPENDESC FAR *LPMIDIOPENDESC;
+
+typedef struct {
+ UINT wDelay;
+ UINT wResolution;
+ LPTIMECALLBACK lpFunction;
+ DWORD dwUser;
+ UINT wFlags;
+ } TIMEREVENT;
+typedef TIMEREVENT FAR *LPTIMEREVENT;
+
+typedef struct {
+ UINT wDeviceID; /* device ID */
+ LPSTR lpstrParams; /* parameter string for entry in SYSTEM.INI */
+ UINT wCustomCommandTable; /* custom command table (0xFFFF if none) */
+ /* filled in by the driver */
+ UINT wType; /* driver type */
+ /* filled in by the driver */
+ } MCI_OPEN_DRIVER_PARMS;
+typedef MCI_OPEN_DRIVER_PARMS FAR * LPMCI_OPEN_DRIVER_PARMS;
+
+DWORD WINAPI mciGetDriverData(UINT uDeviceID);
+BOOL WINAPI mciSetDriverData(UINT uDeviceID, DWORD dwData);
+UINT WINAPI mciDriverYield(UINT uDeviceID);
+BOOL WINAPI mciDriverNotify(HWND hwndCallback, UINT uDeviceID,
+ UINT uStatus);
+UINT WINAPI mciLoadCommandResource(HINSTANCE hInstance,
+ LPCSTR lpResName, UINT uType);
+BOOL WINAPI mciFreeCommandResource(UINT uTable);
+
+#define DCB_NULL 0x0000
+#define DCB_WINDOW 0x0001 /* dwCallback is a HWND */
+#define DCB_TASK 0x0002 /* dwCallback is a HTASK */
+#define DCB_FUNCTION 0x0003 /* dwCallback is a FARPROC */
+#define DCB_TYPEMASK 0x0007
+#define DCB_NOSWITCH 0x0008 /* don't switch stacks for callback */
+
BOOL DriverCallback(DWORD dwCallBack, UINT uFlags, HANDLE hDev,
WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
DWORD auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
diff --git a/include/options.h b/include/options.h
index 5003b9f..3caf1fd 100644
--- a/include/options.h
+++ b/include/options.h
@@ -15,7 +15,6 @@
int usePrivateMap;
int synchronous;
int nobackingstore;
- int nosaveunders;
short cmdShow;
int relay_debug;
int debug;
diff --git a/include/windows.h b/include/windows.h
index 5281abd..c389455 100644
--- a/include/windows.h
+++ b/include/windows.h
@@ -2790,8 +2790,8 @@
Fc(BOOL,LineTo,HDC,a,short,b,short,c)
Fc(WORD,GetInternalWindowPos,HWND,a,LPRECT,b,LPPOINT,c)
Fc(LONG,_llseek,INT,a,LONG,b,INT,c)
-Fc(INT,_lread,INT,a,LPSTR,b,INT,c)
-Fc(INT,_lwrite,INT,a,LPSTR,b,INT,c)
+Fc(INT,_lread,INT,a,LPSTR,b,WORD,c)
+Fc(INT,_lwrite,INT,a,LPSTR,b,WORD,c)
Fc(int,FillRect,HDC,a,LPRECT,b,HBRUSH,c)
Fc(DWORD,MoveTo,HDC,a,short,b,short,c)
Fc(BOOL,CheckMenuItem,HMENU,a,WORD,b,WORD,c)
diff --git a/loader/main.c b/loader/main.c
index 8161854..459e7bc 100644
--- a/loader/main.c
+++ b/loader/main.c
@@ -264,7 +264,10 @@
strncpy(filename, Argv[0], p - Argv[0]);
filename[p - Argv[0]] = '\0';
strcat(WindowsPath, ";");
- strcat(WindowsPath, filename);
+ if (strchr(filename, '/'))
+ strcat(WindowsPath, GetDosFileName(filename));
+ else
+ strcat(WindowsPath, filename);
}
if ((hInstMain = LoadImage(Argv[0], EXE, 1)) < 32) {
diff --git a/misc/Imakefile b/misc/Imakefile
index 5967031..09d194c 100644
--- a/misc/Imakefile
+++ b/misc/Imakefile
@@ -16,7 +16,9 @@
keyboard.c \
lstr.c \
main.c \
+ mcicda.c \
message.c \
+ mmaux.c \
mmsystem.c \
network.c \
profile.c \
diff --git a/misc/audio.c b/misc/audio.c
index 008029f..153223f 100644
--- a/misc/audio.c
+++ b/misc/audio.c
@@ -4,20 +4,109 @@
* Copyright 1994 Martin Ayotte
*/
+#define DEBUG_MCIWAVE
+
static char Copyright[] = "Copyright Martin Ayotte, 1994";
#include "stdio.h"
-#include "windows.h"
#include "win.h"
#include "user.h"
#include "driver.h"
#include "mmsystem.h"
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/soundcard.h>
+
+#define SOUND_DEV "/dev/dsp"
+
+#ifdef SOUND_VERSION
+#define IOCTL(a,b,c) ioctl(a,b,&c)
+#else
+#define IOCTL(a,b,c) (c = ioctl(a,b,c) )
+#endif
+
+#define MAX_WAVOUTDRV 2
+#define MAX_WAVINDRV 2
+#define MAX_MCIWAVDRV 2
+
+typedef struct {
+ int unixdev;
+ int state;
+ DWORD bufsize;
+ WAVEOPENDESC waveDesc;
+ WORD wFlags;
+ PCMWAVEFORMAT Format;
+ LPWAVEHDR lpQueueHdr;
+ DWORD dwTotalPlayed;
+ } LINUX_WAVEOUT;
+
+typedef struct {
+ int unixdev;
+ int state;
+ DWORD bufsize; /* Linux '/dev/dsp' give us that size */
+ WAVEOPENDESC waveDesc;
+ WORD wFlags;
+ PCMWAVEFORMAT Format;
+ LPWAVEHDR lpQueueHdr;
+ DWORD dwTotalRecorded;
+ } LINUX_WAVEIN;
+
+typedef struct {
+ int nUseCount; /* Incremented for each shared open */
+ BOOL fShareable; /* TRUE if first open was shareable */
+ WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
+ HANDLE hCallback; /* Callback handle for pending notification */
+ int hFile; /* file handle open as Element */
+ MCI_WAVE_OPEN_PARMS openParms;
+ PCMWAVEFORMAT WaveFormat;
+ WAVEHDR WaveHdr;
+ } LINUX_MCIWAVE;
+
+static LINUX_WAVEOUT WOutDev[MAX_WAVOUTDRV];
+static LINUX_WAVEIN WInDev[MAX_WAVOUTDRV];
+static LINUX_MCIWAVE MCIWavDev[MAX_MCIWAVDRV];
+
+DWORD WAVE_mciOpen(DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lpParms);
+DWORD WAVE_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms);
+DWORD WAVE_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms);
+DWORD WAVE_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms);
+DWORD WAVE_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
+DWORD WAVE_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
+DWORD WAVE_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms);
+DWORD WAVE_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms);
+DWORD WAVE_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms);
+DWORD WAVE_mciGetDevCaps(UINT wDevID, DWORD dwFlags, LPMCI_GETDEVCAPS_PARMS lpParms);
+DWORD WAVE_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms);
+
+DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPS lpCaps, DWORD dwSize);
+DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags);
+DWORD wodClose(WORD wDevID);
+DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize);
+DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize);
+DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize);
+
+
+/**************************************************************************
+* WAVE_NotifyClient [internal]
+*/
+DWORD WAVE_NotifyClient(UINT wDevID, WORD wMsg,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ if (WInDev[wDevID].wFlags != DCB_NULL && !DriverCallback(
+ WInDev[wDevID].waveDesc.dwCallBack, WInDev[wDevID].wFlags,
+ WInDev[wDevID].waveDesc.hWave, wMsg,
+ WInDev[wDevID].waveDesc.dwInstance, dwParam1, dwParam2)) {
+ printf("WAVE_NotifyClient // can't notify client !\n");
+ return MMSYSERR_NOERROR;
+ }
+}
+
/**************************************************************************
* AUDIO_DriverProc [sample driver]
*/
-LRESULT AUDIO_DriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
+LRESULT WAVE_DriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
DWORD dwParam1, DWORD dwParam2)
{
switch(wMsg) {
@@ -43,17 +132,1320 @@
return (LRESULT)DRVCNF_RESTART;
case DRV_REMOVE:
return (LRESULT)DRVCNF_RESTART;
+ case MCI_OPEN_DRIVER:
+ case MCI_OPEN:
+ return WAVE_mciOpen(dwParam1, (LPMCI_WAVE_OPEN_PARMS)dwParam2);
+ case MCI_CLOSE_DRIVER:
+ case MCI_CLOSE:
+ return WAVE_mciClose(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
+ case MCI_PLAY:
+ return WAVE_mciPlay(dwDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
+ case MCI_RECORD:
+ return WAVE_mciRecord(dwDevID, dwParam1, (LPMCI_RECORD_PARMS)dwParam2);
+ case MCI_STOP:
+ return WAVE_mciStop(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
+ case MCI_SET:
+ return WAVE_mciSet(dwDevID, dwParam1, (LPMCI_SET_PARMS)dwParam2);
+ case MCI_PAUSE:
+ return WAVE_mciPause(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
+ case MCI_RESUME:
+ return WAVE_mciResume(dwDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
+ case MCI_STATUS:
+ return WAVE_mciStatus(dwDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
+ case MCI_GETDEVCAPS:
+ return WAVE_mciGetDevCaps(dwDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
+ case MCI_INFO:
+ return WAVE_mciInfo(dwDevID, dwParam1, (LPMCI_INFO_PARMS)dwParam2);
default:
return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
}
}
/**************************************************************************
+* WAVE_mciOpen */
+DWORD WAVE_mciOpen(DWORD dwFlags, LPMCI_WAVE_OPEN_PARMS lpParms)
+{
+ int hFile;
+ UINT wDevID;
+ OFSTRUCT OFstruct;
+ LPPCMWAVEFORMAT lpWaveFormat;
+ WAVEOPENDESC WaveDesc;
+ DWORD dwRet;
+ char str[128];
+ LPSTR ptr;
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciOpen(%08X, %08X)\n", dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ wDevID = lpParms->wDeviceID;
+ if (MCIWavDev[wDevID].nUseCount > 0) {
+ /* The driver already open on this channel */
+ /* If the driver was opened shareable before and this open specifies */
+ /* shareable then increment the use count */
+ if (MCIWavDev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
+ ++MCIWavDev[wDevID].nUseCount;
+ else
+ return MCIERR_MUST_USE_SHAREABLE;
+ }
+ else {
+ MCIWavDev[wDevID].nUseCount = 1;
+ MCIWavDev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
+ }
+ if (dwFlags & MCI_OPEN_ELEMENT) {
+ printf("WAVE_mciOpen // MCI_OPEN_ELEMENT '%s' !\n",
+ lpParms->lpstrElementName);
+ printf("WAVE_mciOpen // cdw='%s'\n", DOS_GetCurrentDir(DOS_GetDefaultDrive()));
+ if (strlen(lpParms->lpstrElementName) > 0) {
+ strcpy(str, lpParms->lpstrElementName);
+ AnsiUpper(str);
+ MCIWavDev[wDevID].hFile = _lopen(str, OF_READWRITE);
+ if (MCIWavDev[wDevID].hFile < 1) {
+ MCIWavDev[wDevID].hFile = 0;
+ printf("WAVE_mciOpen // can't find file='%s' !\n", str);
+ return MCIERR_FILE_NOT_FOUND;
+ }
+ }
+ else
+ MCIWavDev[wDevID].hFile = 0;
+ }
+ printf("WAVE_mciOpen // hFile=%u\n", MCIWavDev[wDevID].hFile);
+ memcpy(&MCIWavDev[wDevID].openParms, lpParms, sizeof(MCI_WAVE_OPEN_PARMS));
+ MCIWavDev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
+ lpWaveFormat = &MCIWavDev[wDevID].WaveFormat;
+ WaveDesc.hWave = 0;
+ WaveDesc.lpFormat = (LPWAVEFORMAT)lpWaveFormat;
+ lpWaveFormat->wf.wFormatTag = WAVE_FORMAT_PCM;
+ lpWaveFormat->wBitsPerSample = 8;
+ lpWaveFormat->wf.nChannels = 1;
+ lpWaveFormat->wf.nSamplesPerSec = 11025;
+ lpWaveFormat->wf.nAvgBytesPerSec = 11025;
+ lpWaveFormat->wf.nBlockAlign = 1;
+ dwRet = wodMessage(0, WODM_OPEN, 0, (DWORD)&WaveDesc, CALLBACK_NULL);
+ dwRet = widMessage(0, WIDM_OPEN, 0, (DWORD)&WaveDesc, CALLBACK_NULL);
+ return 0;
+}
+
+/**************************************************************************
+* WAVE_mciClose [internal]
+*/
+DWORD WAVE_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
+{
+ DWORD dwRet;
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciClose(%u, %08X, %08X);\n", wDevID, dwParam, lpParms);
+#endif
+ MCIWavDev[wDevID].nUseCount--;
+ if (MCIWavDev[wDevID].nUseCount == 0) {
+ if (MCIWavDev[wDevID].hFile != 0) {
+ close(MCIWavDev[wDevID].hFile);
+ MCIWavDev[wDevID].hFile = 0;
+ }
+ dwRet = wodMessage(0, WODM_CLOSE, 0, 0L, 0L);
+ if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
+ dwRet = widMessage(0, WIDM_CLOSE, 0, 0L, 0L);
+ if (dwRet != MMSYSERR_NOERROR) return MCIERR_INTERNAL;
+ }
+ return 0;
+}
+
+
+/**************************************************************************
+* WAVE_mciPlay [internal]
+*/
+DWORD WAVE_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
+{
+ int count;
+ int start, end;
+ LPWAVEHDR lpWaveHdr;
+ DWORD dwRet;
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciPlay(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (MCIWavDev[wDevID].hFile == 0) {
+ printf("WAVE_mciPlay // can't find file='%s' !\n",
+ MCIWavDev[wDevID].openParms.lpstrElementName);
+ return MCIERR_FILE_NOT_FOUND;
+ }
+ start = 1; end = 99999;
+ if (dwFlags & MCI_FROM) {
+ start = lpParms->dwFrom;
+ printf("WAVE_mciPlay // MCI_FROM=%d \n", start);
+ }
+ if (dwFlags & MCI_TO) {
+ end = lpParms->dwTo;
+ printf("WAVE_mciPlay // MCI_TO=%d \n", end);
+ }
+/*
+ if (dwFlags & MCI_NOTIFY) {
+ printf("WAVE_mciPlay // MCI_NOTIFY %08X !\n", lpParms->dwCallback);
+ switch(fork()) {
+ case -1:
+ printf("WAVE_mciPlay // Can't 'fork' process !\n");
+ break;
+ case 0:
+ break;
+ default:
+ printf("WAVE_mciPlay // process started ! return to caller...\n");
+ return 0;
+ }
+ }
+*/
+ lpWaveHdr = &MCIWavDev[wDevID].WaveHdr;
+ lpWaveHdr->lpData = (LPSTR) malloc(64000);
+ lpWaveHdr->dwBufferLength = 32000;
+ lpWaveHdr->dwUser = 0L;
+ lpWaveHdr->dwFlags = 0L;
+ lpWaveHdr->dwLoops = 0L;
+ dwRet = wodMessage(0, WODM_PREPARE, 0, (DWORD)lpWaveHdr, sizeof(WAVEHDR));
+ printf("WAVE_mciPlay // after WODM_PREPARE \n");
+ while(TRUE) {
+/* printf("WAVE_mciPlay // before 'read' hFile=%u lpData=%08X dwBufferLength=%u\n",
+ MCIWavDev[wDevID].hFile, lpWaveHdr->lpData, lpWaveHdr->dwBufferLength); */
+ count = _lread(MCIWavDev[wDevID].hFile, lpWaveHdr->lpData, lpWaveHdr->dwBufferLength);
+ if (count < 1) break;
+ lpWaveHdr->dwBytesRecorded = count;
+ printf("WAVE_mciPlay // before WODM_WRITE lpWaveHdr=%08X dwBytesRecorded=%u\n",
+ lpWaveHdr, lpWaveHdr->dwBytesRecorded);
+ dwRet = wodMessage(0, WODM_WRITE, 0, (DWORD)lpWaveHdr, sizeof(WAVEHDR));
+ }
+ printf("WAVE_mciPlay // before WODM_UNPREPARE \n");
+ dwRet = wodMessage(0, WODM_UNPREPARE, 0, (DWORD)lpWaveHdr, sizeof(WAVEHDR));
+ printf("WAVE_mciPlay // after WODM_UNPREPARE \n");
+ if (lpWaveHdr->lpData != NULL) {
+ free(lpWaveHdr->lpData);
+ lpWaveHdr->lpData = NULL;
+ }
+ if (dwFlags & MCI_NOTIFY) {
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciPlay // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+#endif
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+
+/**************************************************************************
+* WAVE_mciRecord [internal]
+*/
+DWORD WAVE_mciRecord(UINT wDevID, DWORD dwFlags, LPMCI_RECORD_PARMS lpParms)
+{
+ int count;
+ int start, end;
+ LPWAVEHDR lpWaveHdr;
+ DWORD dwRet;
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciRecord(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (MCIWavDev[wDevID].hFile == 0) {
+ printf("WAVE_mciRecord // can't find file='%s' !\n",
+ MCIWavDev[wDevID].openParms.lpstrElementName);
+ return MCIERR_FILE_NOT_FOUND;
+ }
+ start = 1; end = 99999;
+ if (dwFlags & MCI_FROM) {
+ start = lpParms->dwFrom;
+ printf("WAVE_mciRecord // MCI_FROM=%d \n", start);
+ }
+ if (dwFlags & MCI_TO) {
+ end = lpParms->dwTo;
+ printf("WAVE_mciRecord // MCI_TO=%d \n", end);
+ }
+ lpWaveHdr = &MCIWavDev[wDevID].WaveHdr;
+ lpWaveHdr->lpData = (LPSTR) malloc(64000);
+ lpWaveHdr->dwBufferLength = 32000;
+ lpWaveHdr->dwUser = 0L;
+ lpWaveHdr->dwFlags = 0L;
+ lpWaveHdr->dwLoops = 0L;
+ dwRet = widMessage(0, WIDM_PREPARE, 0, (DWORD)lpWaveHdr, sizeof(WAVEHDR));
+ printf("WAVE_mciRecord // after WIDM_PREPARE \n");
+ while(TRUE) {
+ lpWaveHdr->dwBytesRecorded = 0;
+ dwRet = widMessage(0, WIDM_START, 0, 0L, 0L);
+ printf("WAVE_mciRecord // after WIDM_START lpWaveHdr=%08X dwBytesRecorded=%u\n",
+ lpWaveHdr, lpWaveHdr->dwBytesRecorded);
+ if (lpWaveHdr->dwBytesRecorded == 0) break;
+ }
+ printf("WAVE_mciRecord // before WIDM_UNPREPARE \n");
+ dwRet = widMessage(0, WIDM_UNPREPARE, 0, (DWORD)lpWaveHdr, sizeof(WAVEHDR));
+ printf("WAVE_mciRecord // after WIDM_UNPREPARE \n");
+ if (lpWaveHdr->lpData != NULL) {
+ free(lpWaveHdr->lpData);
+ lpWaveHdr->lpData = NULL;
+ }
+ if (dwFlags & MCI_NOTIFY) {
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciRecord // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+#endif
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+
+/**************************************************************************
+* WAVE_mciStop [internal]
+*/
+DWORD WAVE_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
+{
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciStop(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ return 0;
+}
+
+
+/**************************************************************************
+* WAVE_mciPause [internal]
+*/
+DWORD WAVE_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
+{
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciPause(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ return 0;
+}
+
+
+/**************************************************************************
+* WAVE_mciResume [internal]
+*/
+DWORD WAVE_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
+{
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciResume(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ return 0;
+}
+
+
+/**************************************************************************
+* WAVE_mciSet [internal]
+*/
+DWORD WAVE_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
+{
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciSet(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciSet // dwTimeFormat=%08X\n", lpParms->dwTimeFormat);
+ printf("WAVE_mciSet // dwAudio=%08X\n", lpParms->dwAudio);
+#endif
+ if (dwFlags & MCI_SET_TIME_FORMAT) {
+ switch (lpParms->dwTimeFormat) {
+ case MCI_FORMAT_MILLISECONDS:
+ printf("WAVE_mciSet // MCI_FORMAT_MILLISECONDS !\n");
+ break;
+ case MCI_FORMAT_BYTES:
+ printf("WAVE_mciSet // MCI_FORMAT_BYTES !\n");
+ break;
+ case MCI_FORMAT_SAMPLES:
+ printf("WAVE_mciSet // MCI_FORMAT_SAMPLES !\n");
+ break;
+ default:
+ printf("WAVE_mciSet // bad time format !\n");
+ return MCIERR_BAD_TIME_FORMAT;
+ }
+ }
+ if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
+ if (dwFlags & MCI_SET_DOOR_OPEN) return MCIERR_UNSUPPORTED_FUNCTION;
+ if (dwFlags & MCI_SET_DOOR_CLOSED) return MCIERR_UNSUPPORTED_FUNCTION;
+ if (dwFlags & MCI_SET_AUDIO) {
+ printf("WAVE_mciSet // MCI_SET_AUDIO !\n");
+ }
+ if (dwFlags && MCI_SET_ON) {
+ printf("WAVE_mciSet // MCI_SET_ON !\n");
+ if (dwFlags && MCI_SET_AUDIO_LEFT) {
+ printf("WAVE_mciSet // MCI_SET_AUDIO_LEFT !\n");
+ }
+ if (dwFlags && MCI_SET_AUDIO_RIGHT) {
+ printf("WAVE_mciSet // MCI_SET_AUDIO_RIGHT !\n");
+ }
+ }
+ if (dwFlags & MCI_SET_OFF) {
+ printf("WAVE_mciSet // MCI_SET_OFF !\n");
+ }
+ if (dwFlags & MCI_WAVE_INPUT) {
+ printf("WAVE_mciSet // MCI_WAVE_INPUT !\n");
+ }
+ if (dwFlags & MCI_WAVE_OUTPUT) {
+ printf("WAVE_mciSet // MCI_WAVE_OUTPUT !\n");
+ }
+ if (dwFlags & MCI_WAVE_SET_ANYINPUT) {
+ printf("WAVE_mciSet // MCI_WAVE_SET_ANYINPUT !\n");
+ }
+ if (dwFlags & MCI_WAVE_SET_ANYOUTPUT) {
+ printf("WAVE_mciSet // MCI_WAVE_SET_ANYOUTPUT !\n");
+ }
+ if (dwFlags & MCI_WAVE_SET_AVGBYTESPERSEC) {
+ printf("WAVE_mciSet // MCI_WAVE_SET_AVGBYTESPERSEC !\n");
+ }
+ if (dwFlags & MCI_WAVE_SET_BITSPERSAMPLE) {
+ printf("WAVE_mciSet // MCI_WAVE_SET_BITSPERSAMPLE !\n");
+ }
+ if (dwFlags & MCI_WAVE_SET_BLOCKALIGN) {
+ printf("WAVE_mciSet // MCI_WAVE_SET_BLOCKALIGN !\n");
+ }
+ if (dwFlags & MCI_WAVE_SET_CHANNELS) {
+ printf("WAVE_mciSet // MCI_WAVE_SET_CHANNELS !\n");
+ }
+ if (dwFlags & MCI_WAVE_SET_FORMATTAG) {
+ printf("WAVE_mciSet // MCI_WAVE_SET_FORMATTAG !\n");
+ }
+ if (dwFlags & MCI_WAVE_SET_SAMPLESPERSEC) {
+ printf("WAVE_mciSet // MCI_WAVE_SET_SAMPLESPERSEC !\n");
+ }
+ return 0;
+}
+
+
+/**************************************************************************
+* WAVE_mciStatus [internal]
+*/
+DWORD WAVE_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
+{
+#ifdef DEBUG_MCIWAVE
+ printf("WAVE_mciStatus(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (dwFlags & MCI_STATUS_ITEM) {
+ switch(lpParms->dwItem) {
+ case MCI_STATUS_CURRENT_TRACK:
+ lpParms->dwReturn = 1;
+ break;
+ case MCI_STATUS_LENGTH:
+ lpParms->dwReturn = 5555;
+ if (dwFlags & MCI_TRACK) {
+ lpParms->dwTrack = 1;
+ lpParms->dwReturn = 2222;
+ }
+ break;
+ case MCI_STATUS_MODE:
+ lpParms->dwReturn = MCI_MODE_STOP;
+ break;
+ case MCI_STATUS_MEDIA_PRESENT:
+ printf("WAVE_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_STATUS_NUMBER_OF_TRACKS:
+ lpParms->dwReturn = 1;
+ break;
+ case MCI_STATUS_POSITION:
+ lpParms->dwReturn = 3333;
+ if (dwFlags & MCI_STATUS_START) {
+ lpParms->dwItem = 1;
+ }
+ if (dwFlags & MCI_TRACK) {
+ lpParms->dwTrack = 1;
+ lpParms->dwReturn = 777;
+ }
+ break;
+ case MCI_STATUS_READY:
+ printf("WAVE_mciStatus // MCI_STATUS_READY !\n");
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_STATUS_TIME_FORMAT:
+ printf("WAVE_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
+ lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
+ break;
+ case MCI_WAVE_INPUT:
+ printf("WAVE_mciStatus // MCI_WAVE_INPUT !\n");
+ lpParms->dwReturn = 0;
+ break;
+ case MCI_WAVE_OUTPUT:
+ printf("WAVE_mciStatus // MCI_WAVE_OUTPUT !\n");
+ lpParms->dwReturn = 0;
+ break;
+ case MCI_WAVE_STATUS_AVGBYTESPERSEC:
+ printf("WAVE_mciStatus // MCI_WAVE_STATUS_AVGBYTESPERSEC !\n");
+ lpParms->dwReturn = 22050;
+ break;
+ case MCI_WAVE_STATUS_BITSPERSAMPLE:
+ printf("WAVE_mciStatus // MCI_WAVE_STATUS_BITSPERSAMPLE !\n");
+ lpParms->dwReturn = 8;
+ break;
+ case MCI_WAVE_STATUS_BLOCKALIGN:
+ printf("WAVE_mciStatus // MCI_WAVE_STATUS_BLOCKALIGN !\n");
+ lpParms->dwReturn = 1;
+ break;
+ case MCI_WAVE_STATUS_CHANNELS:
+ printf("WAVE_mciStatus // MCI_WAVE_STATUS_CHANNELS !\n");
+ lpParms->dwReturn = 1;
+ break;
+ case MCI_WAVE_STATUS_FORMATTAG:
+ printf("WAVE_mciStatus // MCI_WAVE_FORMATTAG !\n");
+ lpParms->dwReturn = WAVE_FORMAT_PCM;
+ break;
+ case MCI_WAVE_STATUS_LEVEL:
+ printf("WAVE_mciStatus // MCI_WAVE_STATUS_LEVEL !\n");
+ lpParms->dwReturn = 0xAAAA5555;
+ break;
+ case MCI_WAVE_STATUS_SAMPLESPERSEC:
+ printf("WAVE_mciStatus // MCI_WAVE_STATUS_SAMPLESPERSEC !\n");
+ lpParms->dwReturn = 22050;
+ break;
+ default:
+ printf("WAVE_mciStatus // unknowm command %04X !\n", lpParms->dwItem);
+ return MCIERR_UNRECOGNIZED_COMMAND;
+ }
+ }
+ if (dwFlags & MCI_NOTIFY) {
+ printf("WAVE_mciStatus // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ MCIWavDev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+/**************************************************************************
+* WAVE_mciGetDevCaps [internal]
+*/
+DWORD WAVE_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
+ LPMCI_GETDEVCAPS_PARMS lpParms)
+{
+ printf("WAVE_mciGetDevCaps(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (dwFlags & MCI_GETDEVCAPS_ITEM) {
+ switch(lpParms->dwItem) {
+ case MCI_GETDEVCAPS_CAN_RECORD:
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_GETDEVCAPS_HAS_AUDIO:
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_GETDEVCAPS_HAS_VIDEO:
+ lpParms->dwReturn = FALSE;
+ break;
+ case MCI_GETDEVCAPS_DEVICE_TYPE:
+ lpParms->dwReturn = MCI_DEVTYPE_WAVEFORM_AUDIO;
+ break;
+ case MCI_GETDEVCAPS_USES_FILES:
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_GETDEVCAPS_COMPOUND_DEVICE:
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_GETDEVCAPS_CAN_EJECT:
+ lpParms->dwReturn = FALSE;
+ break;
+ case MCI_GETDEVCAPS_CAN_PLAY:
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_GETDEVCAPS_CAN_SAVE:
+ lpParms->dwReturn = FALSE;
+ break;
+ case MCI_WAVE_GETDEVCAPS_INPUTS:
+ lpParms->dwReturn = 1;
+ break;
+ case MCI_WAVE_GETDEVCAPS_OUTPUTS:
+ lpParms->dwReturn = 1;
+ break;
+ default:
+ return MCIERR_UNRECOGNIZED_COMMAND;
+ }
+ }
+ return 0;
+}
+
+/**************************************************************************
+* WAVE_mciInfo [internal]
+*/
+DWORD WAVE_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms)
+{
+ printf("WAVE_mciInfo(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ lpParms->lpstrReturn = NULL;
+ switch(dwFlags) {
+ case MCI_INFO_PRODUCT:
+ lpParms->lpstrReturn = "Linux Sound System 0.5";
+ break;
+ case MCI_INFO_FILE:
+ lpParms->lpstrReturn = "FileName";
+ break;
+ case MCI_WAVE_INPUT:
+ lpParms->lpstrReturn = "Linux Sound System 0.5";
+ break;
+ case MCI_WAVE_OUTPUT:
+ lpParms->lpstrReturn = "Linux Sound System 0.5";
+ break;
+ default:
+ return MCIERR_UNRECOGNIZED_COMMAND;
+ }
+ if (lpParms->lpstrReturn != NULL)
+ lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
+ else
+ lpParms->dwRetSize = 0;
+ return 0;
+}
+
+
+/*-----------------------------------------------------------------------*/
+
+
+/**************************************************************************
+* wodGetDevCaps [internal]
+*/
+DWORD wodGetDevCaps(WORD wDevID, LPWAVEOUTCAPS lpCaps, DWORD dwSize)
+{
+ int audio;
+ int smplrate;
+ int samplesize = 16;
+ int dsp_stereo = 1;
+ int bytespersmpl;
+ printf("wodGetDevCaps(%u, %08X, %u);\n", wDevID, lpCaps, dwSize);
+ if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
+ audio = open (SOUND_DEV, O_WRONLY, 0);
+ if (audio == -1) return MMSYSERR_NOTENABLED;
+ lpCaps->wMid = 0xFF; /* Manufac ID */
+ lpCaps->wPid = 0x01; /* Product ID */
+ strcpy(lpCaps->szPname, "Linux WAV Driver");
+ lpCaps->dwFormats = 0;
+ lpCaps->dwSupport = 0;
+ lpCaps->wChannels = (IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo) != 0) ? 1 : 2;
+ bytespersmpl = (IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize) != 0) ? 1 : 2;
+ smplrate = 44100;
+ if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
+ lpCaps->dwFormats |= WAVE_FORMAT_4M08;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_4S08;
+ if (bytespersmpl > 1) {
+ lpCaps->dwFormats |= WAVE_FORMAT_4M16;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_4S16;
+ }
+ }
+ smplrate = 22050;
+ if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
+ lpCaps->dwFormats |= WAVE_FORMAT_2M08;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_2S08;
+ if (bytespersmpl > 1) {
+ lpCaps->dwFormats |= WAVE_FORMAT_2M16;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_2S16;
+ }
+ }
+ smplrate = 11025;
+ if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
+ lpCaps->dwFormats |= WAVE_FORMAT_1M08;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_1S08;
+ if (bytespersmpl > 1) {
+ lpCaps->dwFormats |= WAVE_FORMAT_1M16;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_1S16;
+ }
+ }
+ close(audio);
+ printf("wodGetDevCaps // dwFormats = %08X\n", lpCaps->dwFormats);
+ return MMSYSERR_NOERROR;
+}
+
+
+/**************************************************************************
+* wodOpen [internal]
+*/
+DWORD wodOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
+{
+ int audio;
+ int abuf_size;
+ int smplrate;
+ int samplesize;
+ int dsp_stereo;
+ printf("wodOpen(%u, %08X, %08X);\n", wDevID, lpDesc, dwFlags);
+ if (lpDesc == NULL) {
+ printf("Linux 'wodOpen' // Invalid Parameter !\n");
+ return MMSYSERR_INVALPARAM;
+ }
+ if (wDevID >= MAX_WAVOUTDRV) {
+ printf("Linux 'wodOpen' // MAX_WAVOUTDRV reached !\n");
+ return MMSYSERR_ALLOCATED;
+ }
+ WOutDev[wDevID].unixdev = 0;
+ audio = open (SOUND_DEV, O_WRONLY, 0);
+ if (audio == -1) {
+ printf("Linux 'wodOpen' // can't open !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ IOCTL(audio, SNDCTL_DSP_GETBLKSIZE, abuf_size);
+ if (abuf_size < 4096 || abuf_size > 65536) {
+ if (abuf_size == -1)
+ printf("Linux 'wodOpen' // IOCTL can't 'SNDCTL_DSP_GETBLKSIZE' !\n");
+ else
+ printf("Linux 'wodOpen' // SNDCTL_DSP_GETBLKSIZE Invalid bufsize !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ WOutDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
+ switch(WOutDev[wDevID].wFlags) {
+ case DCB_NULL:
+ printf("Linux 'wodOpen' // CALLBACK_NULL !\n");
+ break;
+ case DCB_WINDOW:
+ printf("Linux 'wodOpen' // CALLBACK_WINDOW !\n");
+ break;
+ case DCB_TASK:
+ printf("Linux 'wodOpen' // CALLBACK_TASK !\n");
+ break;
+ case DCB_FUNCTION:
+ printf("Linux 'wodOpen' // CALLBACK_FUNCTION !\n");
+ break;
+ }
+ WOutDev[wDevID].lpQueueHdr = NULL;
+ WOutDev[wDevID].unixdev = audio;
+ WOutDev[wDevID].dwTotalPlayed = 0;
+ WOutDev[wDevID].bufsize = abuf_size;
+ memcpy(&WOutDev[wDevID].waveDesc, lpDesc, sizeof(WAVEOPENDESC));
+ if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
+ printf("Linux 'wodOpen' // Bad format %04X !\n",
+ lpDesc->lpFormat->wFormatTag);
+ return WAVERR_BADFORMAT;
+ }
+ memcpy(&WOutDev[wDevID].Format, lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
+ if (WOutDev[wDevID].Format.wf.nChannels == 0) return WAVERR_BADFORMAT;
+ if (WOutDev[wDevID].Format.wf.nSamplesPerSec == 0) return WAVERR_BADFORMAT;
+ if (WOutDev[wDevID].Format.wBitsPerSample == 0) {
+ WOutDev[wDevID].Format.wBitsPerSample = 8 *
+ (WOutDev[wDevID].Format.wf.nAvgBytesPerSec /
+ WOutDev[wDevID].Format.wf.nSamplesPerSec) /
+ WOutDev[wDevID].Format.wf.nChannels;
+ }
+ samplesize = WOutDev[wDevID].Format.wBitsPerSample;
+ smplrate = WOutDev[wDevID].Format.wf.nSamplesPerSec;
+ dsp_stereo = (WOutDev[wDevID].Format.wf.nChannels > 1) ? TRUE : FALSE;
+ IOCTL(audio, SNDCTL_DSP_SPEED, smplrate);
+ IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize);
+ IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo);
+ printf("Linux 'wodOpen' // wBitsPerSample=%u !\n",
+ WOutDev[wDevID].Format.wBitsPerSample);
+ printf("Linux 'wodOpen' // nSamplesPerSec=%u !\n",
+ WOutDev[wDevID].Format.wf.nSamplesPerSec);
+ printf("Linux 'wodOpen' // nChannels=%u !\n",
+ WOutDev[wDevID].Format.wf.nChannels);
+ if (WAVE_NotifyClient(wDevID, WOM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
+ printf("Linux 'wodOpen' // can't notify client !\n");
+ return MMSYSERR_INVALPARAM;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* wodClose [internal]
+*/
+DWORD wodClose(WORD wDevID)
+{
+ printf("wodClose(%u);\n", wDevID);
+ if (WOutDev[wDevID].unixdev == 0) {
+ printf("Linux 'wodClose' // can't close !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ close(WOutDev[wDevID].unixdev);
+ WOutDev[wDevID].unixdev = 0;
+ WOutDev[wDevID].bufsize = 0;
+ if (WAVE_NotifyClient(wDevID, WOM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
+ printf("Linux 'wodClose' // can't notify client !\n");
+ return MMSYSERR_INVALPARAM;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* wodWrite [internal]
+*/
+DWORD wodWrite(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+ printf("wodWrite(%u, %08X, %08X);\n", wDevID, lpWaveHdr, dwSize);
+ if (WOutDev[wDevID].unixdev == 0) {
+ printf("Linux 'wodWrite' // can't play !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (lpWaveHdr->lpData == NULL) return WAVERR_UNPREPARED;
+ if (!(lpWaveHdr->dwFlags & WHDR_PREPARED)) return WAVERR_UNPREPARED;
+ if (lpWaveHdr->dwFlags & WHDR_INQUEUE) return WAVERR_STILLPLAYING;
+ lpWaveHdr->dwFlags &= ~WHDR_DONE;
+ lpWaveHdr->dwFlags |= WHDR_INQUEUE;
+ printf("wodWrite() // dwBytesRecorded %u !\n", lpWaveHdr->dwBytesRecorded);
+ if (write (WOutDev[wDevID].unixdev, lpWaveHdr->lpData,
+ lpWaveHdr->dwBytesRecorded) != lpWaveHdr->dwBytesRecorded) {
+ return MMSYSERR_NOTENABLED;
+ }
+ lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
+ lpWaveHdr->dwFlags |= WHDR_DONE;
+ if (WAVE_NotifyClient(wDevID, WOM_DONE, 0L, 0L) != MMSYSERR_NOERROR) {
+ printf("Linux 'wodWrite' // can't notify client !\n");
+ return MMSYSERR_INVALPARAM;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* wodPrepare [internal]
+*/
+DWORD wodPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+ printf("wodPrepare(%u, %08X, %08X);\n", wDevID, lpWaveHdr, dwSize);
+ if (WOutDev[wDevID].unixdev == 0) {
+ printf("Linux 'wodPrepare' // can't prepare !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (WOutDev[wDevID].lpQueueHdr != NULL) {
+ printf("Linux 'wodPrepare' // already prepare !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ WOutDev[wDevID].dwTotalPlayed = 0;
+ WOutDev[wDevID].lpQueueHdr = lpWaveHdr;
+ if (lpWaveHdr->dwFlags & WHDR_INQUEUE) return WAVERR_STILLPLAYING;
+ lpWaveHdr->dwFlags |= WHDR_PREPARED;
+ lpWaveHdr->dwFlags &= ~WHDR_DONE;
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* wodUnprepare [internal]
+*/
+DWORD wodUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+ printf("wodUnprepare(%u, %08X, %08X);\n", wDevID, lpWaveHdr, dwSize);
+ if (WOutDev[wDevID].unixdev == 0) {
+ printf("Linux 'wodUnprepare' // can't unprepare !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* wodRestart [internal]
+*/
+DWORD wodRestart(WORD wDevID)
+{
+ printf("wodRestart(%u);\n", wDevID);
+ if (WOutDev[wDevID].unixdev == 0) {
+ printf("Linux 'wodRestart' // can't restart !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* wodReset [internal]
+*/
+DWORD wodReset(WORD wDevID)
+{
+ printf("wodReset(%u);\n", wDevID);
+ if (WOutDev[wDevID].unixdev == 0) {
+ printf("Linux 'wodReset' // can't reset !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+
+/**************************************************************************
+* wodGetPosition [internal]
+*/
+DWORD wodGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
+{
+ int time;
+ printf("wodGetPosition(%u, %08X, %u);\n", wDevID, lpTime, uSize);
+ if (WOutDev[wDevID].unixdev == 0) {
+ printf("Linux 'wodGetPosition' // can't get pos !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (lpTime == NULL) return MMSYSERR_INVALPARAM;
+TryAGAIN:
+ switch(lpTime->wType) {
+ case TIME_BYTES:
+ lpTime->u.cb = WOutDev[wDevID].dwTotalPlayed;
+ printf("wodGetPosition // TIME_BYTES=%u\n", lpTime->u.cb);
+ break;
+ case TIME_SAMPLES:
+ lpTime->u.sample = WOutDev[wDevID].dwTotalPlayed * 8 /
+ WOutDev[wDevID].Format.wBitsPerSample;
+ printf("wodGetPosition // TIME_SAMPLES=%u\n", lpTime->u.sample);
+ break;
+ case TIME_MS:
+ lpTime->u.ms = WOutDev[wDevID].dwTotalPlayed /
+ (WOutDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
+ printf("wodGetPosition // TIME_MS=%u\n", lpTime->u.ms);
+ break;
+ case TIME_SMPTE:
+ time = WOutDev[wDevID].dwTotalPlayed /
+ (WOutDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
+ lpTime->u.smpte.hour = time / 108000;
+ time -= lpTime->u.smpte.hour * 108000;
+ lpTime->u.smpte.min = time / 1800;
+ time -= lpTime->u.smpte.min * 1800;
+ lpTime->u.smpte.sec = time / 30;
+ time -= lpTime->u.smpte.sec * 30;
+ lpTime->u.smpte.frame = time;
+ lpTime->u.smpte.fps = 30;
+ printf("wodGetPosition // TIME_SMPTE=%02u:%02u:%02u:%02u\n",
+ lpTime->u.smpte.hour, lpTime->u.smpte.min,
+ lpTime->u.smpte.sec, lpTime->u.smpte.frame);
+ break;
+ default:
+ printf("wodGetPosition() format not supported ! use TIME_MS !\n");
+ lpTime->wType = TIME_MS;
+ goto TryAGAIN;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* wodSetVolume [internal]
+*/
+DWORD wodSetVolume(WORD wDevID, DWORD dwParam)
+{
+ int mixer;
+ int volume = 50;
+ printf("wodSetVolume(%u, %08X);\n", wDevID, dwParam);
+ if (WOutDev[wDevID].unixdev == 0) {
+ printf("Linux 'wodSetVolume' // can't set volume !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if ((mixer = open("/dev/mixer", O_RDWR)) < 0) {
+ printf("Linux 'wodSetVolume' // mixer device not available !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (ioctl(mixer, SOUND_MIXER_WRITE_PCM, &volume) == -1) {
+ printf("Linux 'wodSetVolume' // unable set mixer !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ close(mixer);
+ return MMSYSERR_NOERROR;
+}
+
+
+/**************************************************************************
* wodMessage [sample driver]
*/
DWORD wodMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
+ printf("wodMessage(%u, %04X, %08X, %08X, %08X);\n",
+ wDevID, wMsg, dwUser, dwParam1, dwParam2);
+ switch(wMsg) {
+ case WODM_OPEN:
+ return wodOpen(wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
+ case WODM_CLOSE:
+ return wodClose(wDevID);
+ case WODM_WRITE:
+ return wodWrite(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
+ case WODM_PAUSE:
+ return 0L;
+ case WODM_GETPOS:
+ return wodGetPosition(wDevID, (LPMMTIME)dwParam1, dwParam2);
+ case WODM_BREAKLOOP:
+ return 0L;
+ case WODM_PREPARE:
+ return wodPrepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
+ case WODM_UNPREPARE:
+ return wodUnprepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
+ case WODM_GETDEVCAPS:
+ return wodGetDevCaps(wDevID, (LPWAVEOUTCAPS)dwParam1, dwParam2);
+ case WODM_GETNUMDEVS:
+ return 1L;
+ case WODM_GETPITCH:
+ return 0L;
+ case WODM_SETPITCH:
+ return 0L;
+ case WODM_GETPLAYBACKRATE:
+ return 0L;
+ case WODM_SETPLAYBACKRATE:
+ return 0L;
+ case WODM_GETVOLUME:
+ return 0L;
+ case WODM_SETVOLUME:
+ return wodSetVolume(wDevID, dwParam1);
+ case WODM_RESTART:
+ return wodRestart(wDevID);
+ case WODM_RESET:
+ return wodReset(wDevID);
+ }
+ return MMSYSERR_NOTSUPPORTED;
+}
+
+
+/*-----------------------------------------------------------------------*/
+
+/**************************************************************************
+* widGetDevCaps [internal]
+*/
+DWORD widGetDevCaps(WORD wDevID, LPWAVEINCAPS lpCaps, DWORD dwSize)
+{
+ int audio;
+ int smplrate;
+ int samplesize = 16;
+ int dsp_stereo = 1;
+ int bytespersmpl;
+ printf("widGetDevCaps(%u, %08X, %u);\n", wDevID, lpCaps, dwSize);
+ if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
+ audio = open (SOUND_DEV, O_RDONLY, 0);
+ if (audio == -1) return MMSYSERR_NOTENABLED;
+ lpCaps->wMid = 0xFF; /* Manufac ID */
+ lpCaps->wPid = 0x01; /* Product ID */
+ strcpy(lpCaps->szPname, "Linux WAV Driver");
+ lpCaps->dwFormats = 0;
+ lpCaps->wChannels = (IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo) != 0) ? 1 : 2;
+ bytespersmpl = (IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize) != 0) ? 1 : 2;
+ smplrate = 44100;
+ if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
+ lpCaps->dwFormats |= WAVE_FORMAT_4M08;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_4S08;
+ if (bytespersmpl > 1) {
+ lpCaps->dwFormats |= WAVE_FORMAT_4M16;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_4S16;
+ }
+ }
+ smplrate = 22050;
+ if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
+ lpCaps->dwFormats |= WAVE_FORMAT_2M08;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_2S08;
+ if (bytespersmpl > 1) {
+ lpCaps->dwFormats |= WAVE_FORMAT_2M16;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_2S16;
+ }
+ }
+ smplrate = 11025;
+ if (IOCTL(audio, SNDCTL_DSP_SPEED, smplrate) == 0) {
+ lpCaps->dwFormats |= WAVE_FORMAT_1M08;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_1S08;
+ if (bytespersmpl > 1) {
+ lpCaps->dwFormats |= WAVE_FORMAT_1M16;
+ if (lpCaps->wChannels > 1) lpCaps->dwFormats |= WAVE_FORMAT_1S16;
+ }
+ }
+ close(audio);
+ printf("widGetDevCaps // dwFormats = %08X\n", lpCaps->dwFormats);
+ return MMSYSERR_NOERROR;
+}
+
+
+/**************************************************************************
+* widOpen [internal]
+*/
+DWORD widOpen(WORD wDevID, LPWAVEOPENDESC lpDesc, DWORD dwFlags)
+{
+ int audio;
+ int abuf_size;
+ int smplrate;
+ int samplesize;
+ int dsp_stereo;
+ printf("widOpen(%u, %08X, %08X);\n", wDevID, lpDesc, dwFlags);
+ if (lpDesc == NULL) {
+ printf("Linux 'widOpen' // Invalid Parameter !\n");
+ return MMSYSERR_INVALPARAM;
+ }
+ if (wDevID >= MAX_WAVINDRV) {
+ printf("Linux 'widOpen' // MAX_WAVINDRV reached !\n");
+ return MMSYSERR_ALLOCATED;
+ }
+ WInDev[wDevID].unixdev = 0;
+ audio = open (SOUND_DEV, O_RDONLY, 0);
+ if (audio == -1) {
+ printf("Linux 'widOpen' // can't open !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ IOCTL(audio, SNDCTL_DSP_GETBLKSIZE, abuf_size);
+ if (abuf_size < 4096 || abuf_size > 65536) {
+ if (abuf_size == -1)
+ printf("Linux 'widOpen' // IOCTL can't 'SNDCTL_DSP_GETBLKSIZE' !\n");
+ else
+ printf("Linux 'widOpen' // SNDCTL_DSP_GETBLKSIZE Invalid bufsize !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ WInDev[wDevID].wFlags = HIWORD(dwFlags & CALLBACK_TYPEMASK);
+ switch(WInDev[wDevID].wFlags) {
+ case DCB_NULL:
+ printf("Linux 'widOpen' // CALLBACK_NULL !\n");
+ break;
+ case DCB_WINDOW:
+ printf("Linux 'widOpen' // CALLBACK_WINDOW !\n");
+ break;
+ case DCB_TASK:
+ printf("Linux 'widOpen' // CALLBACK_TASK !\n");
+ break;
+ case DCB_FUNCTION:
+ printf("Linux 'widOpen' // CALLBACK_FUNCTION !\n");
+ break;
+ }
+ WInDev[wDevID].lpQueueHdr = NULL;
+ WInDev[wDevID].unixdev = audio;
+ WInDev[wDevID].bufsize = abuf_size;
+ WInDev[wDevID].dwTotalRecorded = 0;
+ memcpy(&WInDev[wDevID].waveDesc, lpDesc, sizeof(WAVEOPENDESC));
+ if (lpDesc->lpFormat->wFormatTag != WAVE_FORMAT_PCM) {
+ printf("Linux 'widOpen' // Bad format %04X !\n",
+ lpDesc->lpFormat->wFormatTag);
+ return WAVERR_BADFORMAT;
+ }
+ memcpy(&WInDev[wDevID].Format, lpDesc->lpFormat, sizeof(PCMWAVEFORMAT));
+ WInDev[wDevID].Format.wBitsPerSample = 8; /* <-------------- */
+ if (WInDev[wDevID].Format.wf.nChannels == 0) return WAVERR_BADFORMAT;
+ if (WInDev[wDevID].Format.wf.nSamplesPerSec == 0) return WAVERR_BADFORMAT;
+ if (WInDev[wDevID].Format.wBitsPerSample == 0) {
+ WInDev[wDevID].Format.wBitsPerSample = 8 *
+ (WInDev[wDevID].Format.wf.nAvgBytesPerSec /
+ WInDev[wDevID].Format.wf.nSamplesPerSec) /
+ WInDev[wDevID].Format.wf.nChannels;
+ }
+ samplesize = WInDev[wDevID].Format.wBitsPerSample;
+ smplrate = WInDev[wDevID].Format.wf.nSamplesPerSec;
+ dsp_stereo = (WInDev[wDevID].Format.wf.nChannels > 1) ? TRUE : FALSE;
+ IOCTL(audio, SNDCTL_DSP_SPEED, smplrate);
+ IOCTL(audio, SNDCTL_DSP_SAMPLESIZE, samplesize);
+ IOCTL(audio, SNDCTL_DSP_STEREO, dsp_stereo);
+#ifdef DEBUG_MCIWAVE
+ printf("Linux 'widOpen' // wBitsPerSample=%u !\n",
+ WInDev[wDevID].Format.wBitsPerSample);
+ printf("Linux 'widOpen' // nSamplesPerSec=%u !\n",
+ WInDev[wDevID].Format.wf.nSamplesPerSec);
+ printf("Linux 'widOpen' // nChannels=%u !\n",
+ WInDev[wDevID].Format.wf.nChannels);
+ printf("Linux 'widOpen' // nAvgBytesPerSec=%u\n",
+ WInDev[wDevID].Format.wf.nAvgBytesPerSec);
+#endif
+ if (WAVE_NotifyClient(wDevID, WIM_OPEN, 0L, 0L) != MMSYSERR_NOERROR) {
+ printf("Linux 'widOpen' // can't notify client !\n");
+ return MMSYSERR_INVALPARAM;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* widClose [internal]
+*/
+DWORD widClose(WORD wDevID)
+{
+ printf("widClose(%u);\n", wDevID);
+ if (WInDev[wDevID].unixdev == 0) {
+ printf("Linux 'widClose' // can't close !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ close(WInDev[wDevID].unixdev);
+ WInDev[wDevID].unixdev = 0;
+ WInDev[wDevID].bufsize = 0;
+ if (WAVE_NotifyClient(wDevID, WIM_CLOSE, 0L, 0L) != MMSYSERR_NOERROR) {
+ printf("Linux 'widClose' // can't notify client !\n");
+ return MMSYSERR_INVALPARAM;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* widAddBuffer [internal]
+*/
+DWORD widAddBuffer(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+ int count = 1;
+ LPWAVEHDR lpWIHdr;
+ printf("widAddBuffer(%u, %08X, %08X);\n", wDevID, lpWaveHdr, dwSize);
+ if (WInDev[wDevID].unixdev == 0) {
+ printf("Linux 'widAddBuffer' // can't do it !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (WInDev[wDevID].lpQueueHdr == NULL ||
+ !(lpWaveHdr->dwFlags & WHDR_PREPARED)) {
+ printf("Linux 'widAddBuffer' // never been prepared !\n");
+ return WAVERR_UNPREPARED;
+ }
+ if ((lpWaveHdr->dwFlags & WHDR_INQUEUE) &&
+ (WInDev[wDevID].lpQueueHdr != lpWaveHdr)) {
+ /* except if it's the one just prepared ... */
+ printf("Linux 'widAddBuffer' // header already in use !\n");
+ return WAVERR_STILLPLAYING;
+ }
+ lpWaveHdr->dwFlags |= WHDR_PREPARED;
+ lpWaveHdr->dwFlags |= WHDR_INQUEUE;
+ lpWaveHdr->dwFlags &= ~WHDR_DONE;
+ lpWaveHdr->dwBytesRecorded = 0;
+ /* added to the queue, except if it's the one just prepared ... */
+ if (WInDev[wDevID].lpQueueHdr != lpWaveHdr) {
+ lpWIHdr = WInDev[wDevID].lpQueueHdr;
+ while (lpWIHdr->lpNext != NULL) {
+ lpWIHdr = lpWIHdr->lpNext;
+ count++;
+ }
+ lpWIHdr->lpNext = lpWaveHdr;
+ count++;
+ }
+ printf("widAddBuffer // buffer added ! (now %u in queue)\n", count);
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* widPrepare [internal]
+*/
+DWORD widPrepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+ printf("widPrepare(%u, %08X, %08X);\n", wDevID, lpWaveHdr, dwSize);
+ if (WInDev[wDevID].unixdev == 0) {
+ printf("Linux 'widPrepare' // can't prepare !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (WInDev[wDevID].lpQueueHdr != NULL) {
+ printf("Linux 'widPrepare' // already prepare !\n");
+ return WAVERR_BADFORMAT;
+ }
+ WInDev[wDevID].dwTotalRecorded = 0;
+ WInDev[wDevID].lpQueueHdr = lpWaveHdr;
+ if (lpWaveHdr->dwFlags & WHDR_INQUEUE) return WAVERR_STILLPLAYING;
+ lpWaveHdr->dwFlags |= WHDR_PREPARED;
+ lpWaveHdr->dwFlags |= WHDR_INQUEUE;
+ lpWaveHdr->dwFlags &= ~WHDR_DONE;
+ lpWaveHdr->dwBytesRecorded = 0;
+ printf("Linux 'widPrepare' // header prepared !\n");
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* widUnprepare [internal]
+*/
+DWORD widUnprepare(WORD wDevID, LPWAVEHDR lpWaveHdr, DWORD dwSize)
+{
+ printf("widUnprepare(%u, %08X, %08X);\n", wDevID, lpWaveHdr, dwSize);
+ if (WInDev[wDevID].unixdev == 0) {
+ printf("Linux 'widUnprepare' // can't unprepare !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ lpWaveHdr->dwFlags &= ~WHDR_PREPARED;
+ lpWaveHdr->dwFlags &= ~WHDR_INQUEUE;
+ lpWaveHdr->dwFlags |= WHDR_DONE;
+ WInDev[wDevID].lpQueueHdr = NULL;
+ printf("Linux 'widUnprepare' // all headers unprepared !\n");
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* widStart [internal]
+*/
+DWORD widStart(WORD wDevID)
+{
+ int count = 1;
+ LPWAVEHDR lpWIHdr;
+ printf("widStart(%u);\n", wDevID);
+ if (WInDev[wDevID].unixdev == 0) {
+ printf("Linux 'widStart' // can't start recording !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (WInDev[wDevID].lpQueueHdr == NULL ||
+ WInDev[wDevID].lpQueueHdr->lpData == NULL) {
+ printf("Linux 'widStart' // never been prepared !\n");
+ return WAVERR_UNPREPARED;
+ }
+ lpWIHdr = WInDev[wDevID].lpQueueHdr;
+ while(lpWIHdr != NULL) {
+ lpWIHdr->dwBufferLength &= 0xFFFF;
+ printf("widStart // recording buf#%u=%08X size=%u \n",
+ count, lpWIHdr->lpData, lpWIHdr->dwBufferLength);
+ fflush(stdout);
+ read (WInDev[wDevID].unixdev, lpWIHdr->lpData,
+ lpWIHdr->dwBufferLength);
+ lpWIHdr->dwBytesRecorded = lpWIHdr->dwBufferLength;
+ WInDev[wDevID].dwTotalRecorded += lpWIHdr->dwBytesRecorded;
+ lpWIHdr->dwFlags &= ~WHDR_INQUEUE;
+ lpWIHdr->dwFlags |= WHDR_DONE;
+ if (WAVE_NotifyClient(wDevID, WIM_DATA, (DWORD)lpWIHdr, 0L) !=
+ MMSYSERR_NOERROR) {
+ printf("Linux 'widStart' // can't notify client !\n");
+ return MMSYSERR_INVALPARAM;
+ }
+ lpWIHdr = lpWIHdr->lpNext;
+ count++;
+ }
+ printf("widStart // end of recording !\n");
+ fflush(stdout);
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* widStop [internal]
+*/
+DWORD widStop(WORD wDevID)
+{
+ printf("widStop(%u);\n", wDevID);
+ if (WInDev[wDevID].unixdev == 0) {
+ printf("Linux 'widStop' // can't stop !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* widReset [internal]
+*/
+DWORD widReset(WORD wDevID)
+{
+ printf("widReset(%u);\n", wDevID);
+ if (WInDev[wDevID].unixdev == 0) {
+ printf("Linux 'widReset' // can't reset !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* widGetPosition [internal]
+*/
+DWORD widGetPosition(WORD wDevID, LPMMTIME lpTime, DWORD uSize)
+{
+ int time;
+#ifdef DEBUG_MCIWAVE
+ printf("widGetPosition(%u, %08X, %u);\n", wDevID, lpTime, uSize);
+#endif
+ if (WInDev[wDevID].unixdev == 0) {
+ printf("Linux 'widGetPosition' // can't get pos !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (lpTime == NULL) return MMSYSERR_INVALPARAM;
+TryAGAIN:
+#ifdef DEBUG_MCIWAVE
+ printf("widGetPosition // wType=%04X !\n", lpTime->wType);
+ printf("widGetPosition // wBitsPerSample=%u\n",
+ WInDev[wDevID].Format.wBitsPerSample);
+ printf("widGetPosition // nSamplesPerSec=%u\n",
+ WInDev[wDevID].Format.wf.nSamplesPerSec);
+ printf("widGetPosition // nChannels=%u\n",
+ WInDev[wDevID].Format.wf.nChannels);
+ printf("widGetPosition // nAvgBytesPerSec=%u\n",
+ WInDev[wDevID].Format.wf.nAvgBytesPerSec);
+ fflush(stdout);
+#endif
+ switch(lpTime->wType) {
+ case TIME_BYTES:
+ lpTime->u.cb = WInDev[wDevID].dwTotalRecorded;
+ printf("widGetPosition // TIME_BYTES=%u\n", lpTime->u.cb);
+ break;
+ case TIME_SAMPLES:
+ lpTime->u.sample = WInDev[wDevID].dwTotalRecorded * 8 /
+ WInDev[wDevID].Format.wBitsPerSample;
+ printf("widGetPosition // TIME_SAMPLES=%u\n", lpTime->u.sample);
+ break;
+ case TIME_MS:
+ lpTime->u.ms = WInDev[wDevID].dwTotalRecorded /
+ (WInDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
+ printf("widGetPosition // TIME_MS=%u\n", lpTime->u.ms);
+ break;
+ case TIME_SMPTE:
+ time = WInDev[wDevID].dwTotalRecorded /
+ (WInDev[wDevID].Format.wf.nAvgBytesPerSec / 1000);
+ lpTime->u.smpte.hour = time / 108000;
+ time -= lpTime->u.smpte.hour * 108000;
+ lpTime->u.smpte.min = time / 1800;
+ time -= lpTime->u.smpte.min * 1800;
+ lpTime->u.smpte.sec = time / 30;
+ time -= lpTime->u.smpte.sec * 30;
+ lpTime->u.smpte.frame = time;
+ lpTime->u.smpte.fps = 30;
+ printf("widGetPosition // TIME_SMPTE=%02u:%02u:%02u:%02u\n",
+ lpTime->u.smpte.hour, lpTime->u.smpte.min,
+ lpTime->u.smpte.sec, lpTime->u.smpte.frame);
+ break;
+ default:
+ printf("widGetPosition() format not supported ! use TIME_MS !\n");
+ lpTime->wType = TIME_MS;
+ goto TryAGAIN;
+ }
+ return MMSYSERR_NOERROR;
}
/**************************************************************************
@@ -62,15 +1454,39 @@
DWORD widMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
+ printf("widMessage(%u, %04X, %08X, %08X, %08X);\n",
+ wDevID, wMsg, dwUser, dwParam1, dwParam2);
+ switch(wMsg) {
+ case WIDM_OPEN:
+ return widOpen(wDevID, (LPWAVEOPENDESC)dwParam1, dwParam2);
+ case WIDM_CLOSE:
+ return widClose(wDevID);
+ case WIDM_ADDBUFFER:
+ return widAddBuffer(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
+ case WIDM_PREPARE:
+ return widPrepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
+ case WIDM_UNPREPARE:
+ return widUnprepare(wDevID, (LPWAVEHDR)dwParam1, dwParam2);
+ case WIDM_GETDEVCAPS:
+ return widGetDevCaps(wDevID, (LPWAVEINCAPS)dwParam1, dwParam2);
+ case WIDM_GETNUMDEVS:
+ return 1L;
+ case WIDM_GETPOS:
+ return widGetPosition(wDevID, (LPMMTIME)dwParam1, dwParam2);
+ case WIDM_RESET:
+ return widReset(wDevID);
+ case WIDM_START:
+ return widStart(wDevID);
+ case WIDM_STOP:
+ return widStop(wDevID);
+ }
+ return MMSYSERR_NOTSUPPORTED;
}
-/**************************************************************************
-* auxMessage [sample driver]
-*/
-DWORD auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
- DWORD dwParam1, DWORD dwParam2)
-{
-}
+
+/*-----------------------------------------------------------------------*/
+
+
/**************************************************************************
* midMessage [sample driver]
@@ -78,6 +1494,7 @@
DWORD midMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
+ return MMSYSERR_NOTENABLED;
}
/**************************************************************************
@@ -86,12 +1503,7 @@
DWORD modMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
DWORD dwParam1, DWORD dwParam2)
{
+ return MMSYSERR_NOTENABLED;
}
-/*
-BOOL DriverCallback(DWORD dwCallBack, UINT uFlags, HANDLE hDev,
- WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2);
-*/
-
-
diff --git a/misc/comm.c b/misc/comm.c
index 8f7f9bc..4c6edfb 100644
--- a/misc/comm.c
+++ b/misc/comm.c
@@ -18,21 +18,12 @@
#include "wine.h"
#include "windows.h"
+#include "comm.h"
/* #define DEBUG_COMM /* */
-#define MAX_PORTS 16
-
int commerror = 0, eventmask = 0;
-struct DosDeviceStruct {
- char *devicename; /* /dev/cua1 */
- int fd;
- int suspended;
- int unget;
- int unget_byte;
-};
-
struct DosDeviceStruct COM[MAX_PORTS];
struct DosDeviceStruct LPT[MAX_PORTS];
diff --git a/misc/dos_fs.c b/misc/dos_fs.c
index dc3b1bb..bb1d3e5 100644
--- a/misc/dos_fs.c
+++ b/misc/dos_fs.c
@@ -27,6 +27,7 @@
#include "msdos.h"
#include "prototypes.h"
#include "autoconf.h"
+#include "comm.h"
/* #define DEBUG /* */
@@ -170,6 +171,11 @@
{
WORD equipment;
int diskdrives = 0;
+ int parallelports = 0;
+ int serialports = 0;
+ int x;
+ extern struct DosDeviceStruct COM[MAX_PORTS];
+ extern struct DosDeviceStruct LPT[MAX_PORTS];
/* borrowed from Ralph Brown's interrupt lists
@@ -190,6 +196,12 @@
bit 1: =1 if math co-processor
bit 0: =1 if diskette available for boot
*/
+/* Currently the only of these bits correctly set are:
+ bits 15-14 } Added by William Owen Smith,
+ bits 11-9 } wos@dcs.warwick.ac.uk
+ bits 7-6
+ bit 2 (always set)
+*/
if (DosDrives[0].rootdir != NULL)
diskdrives++;
@@ -197,8 +209,27 @@
diskdrives++;
if (diskdrives)
diskdrives--;
+
+ for (x=0; x!=MAX_PORTS; x++) {
+ if (COM[x].devicename)
+ serialports++;
+ if (LPT[x].devicename)
+ parallelports++;
+ }
+ if (serialports > 7) /* 3 bits -- maximum value = 7 */
+ serialports=7;
+ if (parallelports > 3) /* 2 bits -- maximum value = 3 */
+ parallelports=3;
- equipment = (diskdrives << 6) || 0x02;
+ equipment = (diskdrives << 6) | (serialports << 9) |
+ (parallelports << 14) | 0x02;
+
+#ifdef DEBUG
+ fprintf(stderr, "DOS_GetEquipment : diskdrives = %d serialports = %d "
+ "parallelports = %d\n"
+ "DOS_GetEquipment : equipment = %d\n",
+ diskdrives, serialports, parallelports, equipment);
+#endif
return (equipment);
}
diff --git a/misc/file.c b/misc/file.c
index e5d7271..29ed173 100644
--- a/misc/file.c
+++ b/misc/file.c
@@ -61,7 +61,7 @@
/***************************************************************************
_lread
***************************************************************************/
-INT _lread (INT hFile, LPSTR lpBuffer, INT wBytes)
+INT _lread (INT hFile, LPSTR lpBuffer, WORD wBytes)
{
int result;
@@ -81,7 +81,7 @@
/****************************************************************************
_lwrite
****************************************************************************/
-INT _lwrite (INT hFile, LPSTR lpBuffer, INT wBytes)
+INT _lwrite (INT hFile, LPSTR lpBuffer, WORD wBytes)
{
int result;
diff --git a/misc/main.c b/misc/main.c
index f238568..4e94a7a 100644
--- a/misc/main.c
+++ b/misc/main.c
@@ -53,7 +53,6 @@
FALSE, /* usePrivateMap */
FALSE, /* synchronous */
FALSE, /* no backing store */
- FALSE, /* no save unders */
SW_SHOWNORMAL, /* cmdShow */
FALSE
};
@@ -69,7 +68,6 @@
{ "-privatemap", ".privatemap", XrmoptionNoArg, (caddr_t)"on" },
{ "-synchronous", ".synchronous", XrmoptionNoArg, (caddr_t)"on" },
{ "-nobackingstore",".nobackingstore", XrmoptionNoArg, (caddr_t)"on" },
- { "-nosaveunders", ".nosaveunders", XrmoptionNoArg, (caddr_t)"on" },
{ "-spy", ".spy", XrmoptionSepArg, (caddr_t)NULL },
{ "-debug", ".debug", XrmoptionNoArg, (caddr_t)"on" },
{ "-relaydbg", ".relaydbg", XrmoptionNoArg, (caddr_t)"on" }
@@ -90,7 +88,6 @@
" -privatemap Use a private color map\n" \
" -synchronous Turn on synchronous display mode\n" \
" -nobackingstore Turn off backing store\n" \
- " -nosaveunders Turn off saveunders\n" \
" -spy file Turn on message spying to the specified file\n" \
" -relaydbg Display call relay information\n"
@@ -245,8 +242,6 @@
Options.usePrivateMap = TRUE;
if (MAIN_GetResource( db, ".synchronous", &value ))
Options.synchronous = TRUE;
- if (MAIN_GetResource( db, ".nosaveunders", &value ))
- Options.nosaveunders = TRUE;
if (MAIN_GetResource( db, ".nobackingstore", &value ))
Options.nobackingstore = TRUE;
if (MAIN_GetResource( db, ".relaydbg", &value ))
@@ -297,16 +292,11 @@
else
win_attr.backing_store = Always;
- if (Options.nosaveunders)
- win_attr.save_under = FALSE;
- else
- win_attr.save_under = TRUE;
-
rootWindow = XCreateWindow( display, DefaultRootWindow(display),
desktopX, desktopY, width, height, 0,
CopyFromParent, InputOutput, CopyFromParent,
- CWEventMask | CWCursor | CWSaveUnder |
- CWBackingStore, &win_attr );
+ CWEventMask | CWCursor |
+ CWBackingStore, &win_attr );
/* Set window manager properties */
diff --git a/misc/mcicda.c b/misc/mcicda.c
new file mode 100644
index 0000000..55497be
--- /dev/null
+++ b/misc/mcicda.c
@@ -0,0 +1,859 @@
+/*
+ * Sample MCI CDAUDIO Wine Driver for Linux
+ *
+ * Copyright 1994 Martin Ayotte
+ */
+
+static char Copyright[] = "Copyright Martin Ayotte, 1994";
+
+/*
+#define DEBUG_CDAUDIO
+*/
+
+#include "stdio.h"
+#include "win.h"
+#include "user.h"
+#include "driver.h"
+#include "mmsystem.h"
+
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/soundcard.h>
+#include <linux/cdrom.h>
+
+#define SOUND_DEV "/dev/dsp"
+#define CDAUDIO_DEV "/dev/sbpcd"
+
+#ifdef SOUND_VERSION
+#define IOCTL(a,b,c) ioctl(a,b,&c)
+#else
+#define IOCTL(a,b,c) (c = ioctl(a,b,c) )
+#endif
+
+#define MAX_CDAUDIODRV 2
+#define MAX_CDAUDIO_TRACKS 256
+
+#define CDFRAMES_PERSEC 75
+#define CDFRAMES_PERMIN 4500
+#define SECONDS_PERMIN 60
+
+typedef struct {
+ int nUseCount; /* Incremented for each shared open */
+ BOOL fShareable; /* TRUE if first open was shareable */
+ WORD wNotifyDeviceID; /* MCI device ID with a pending notification */
+ HANDLE hCallback; /* Callback handle for pending notification */
+ MCI_OPEN_PARMS openParms;
+ DWORD dwTimeFormat;
+ int unixdev;
+ struct cdrom_subchnl sc;
+ int mode;
+ UINT nCurTrack;
+ DWORD dwCurFrame;
+ UINT nTracks;
+ DWORD dwTotalLen;
+ LPDWORD lpdwTrackLen;
+ LPDWORD lpdwTrackPos;
+ DWORD dwFirstOffset;
+ } LINUX_CDAUDIO;
+
+static LINUX_CDAUDIO CDADev[MAX_CDAUDIODRV];
+
+UINT CDAUDIO_GetNumberOfTracks(UINT wDevID);
+BOOL CDAUDIO_GetTracksInfo(UINT wDevID);
+BOOL CDAUDIO_GetCDStatus(UINT wDevID);
+DWORD CDAUDIO_CalcTime(UINT wDevID, DWORD dwFormatType, DWORD dwFrame);
+
+
+/*-----------------------------------------------------------------------*/
+
+
+/**************************************************************************
+* CDAUDIO_mciOpen [internal]
+*/
+DWORD CDAUDIO_mciOpen(DWORD dwFlags, LPMCI_OPEN_PARMS lpParms)
+{
+ UINT wDevID;
+ int cdrom;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciOpen(%08X, %08X);\n", dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ wDevID = lpParms->wDeviceID;
+ if (CDADev[wDevID].nUseCount > 0) {
+ /* The driver already open on this channel */
+ /* If the driver was% op, ened shareable before and this open specifies */
+ /* shareable then increment the use count */
+ if (CDADev[wDevID].fShareable && (dwFlags & MCI_OPEN_SHAREABLE))
+ ++CDADev[wDevID].nUseCount;
+ else
+ return MCIERR_MUST_USE_SHAREABLE;
+ }
+ else {
+ CDADev[wDevID].nUseCount = 1;
+ CDADev[wDevID].fShareable = dwFlags & MCI_OPEN_SHAREABLE;
+ }
+ if (dwFlags & MCI_OPEN_ELEMENT) {
+ printf("CDAUDIO_mciOpen // MCI_OPEN_ELEMENT !\n");
+/* return MCIERR_NO_ELEMENT_ALLOWED; */
+ }
+ memcpy(&CDADev[wDevID].openParms, lpParms, sizeof(MCI_OPEN_PARMS));
+ CDADev[wDevID].wNotifyDeviceID = lpParms->wDeviceID;
+ CDADev[wDevID].unixdev = open (CDAUDIO_DEV, O_RDONLY, 0);
+ if (CDADev[wDevID].unixdev == -1) {
+ printf("CDAUDIO_mciOpen // can't open '%s' !\n", CDAUDIO_DEV);
+ return MCIERR_HARDWARE;
+ }
+ CDADev[wDevID].mode = 0;
+ CDADev[wDevID].dwTimeFormat = MCI_FORMAT_TMSF;
+ CDADev[wDevID].nCurTrack = 0;
+ CDADev[wDevID].nTracks = 0;
+ CDADev[wDevID].dwTotalLen = 0;
+ CDADev[wDevID].dwFirstOffset = 0;
+ CDADev[wDevID].lpdwTrackLen = NULL;
+ CDADev[wDevID].lpdwTrackPos = NULL;
+ if (!CDAUDIO_GetTracksInfo(wDevID)) {
+ printf("CDAUDIO_mciOpen // error reading TracksInfo !\n");
+/* return MCIERR_INTERNAL; */
+ }
+ if (dwFlags & MCI_NOTIFY) {
+ printf("CDAUDIO_mciOpen // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+/**************************************************************************
+* CDAUDIO_mciClose [internal]
+*/
+DWORD CDAUDIO_mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
+{
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciClose(%u, %08X, %08X);\n", wDevID, dwParam, lpParms);
+#endif
+ if (CDADev[wDevID].lpdwTrackLen != NULL) free(CDADev[wDevID].lpdwTrackLen);
+ if (CDADev[wDevID].lpdwTrackPos != NULL) free(CDADev[wDevID].lpdwTrackPos);
+ close(CDADev[wDevID].unixdev);
+}
+
+/**************************************************************************
+* CDAUDIO_mciGetDevCaps [internal]
+*/
+DWORD CDAUDIO_mciGetDevCaps(UINT wDevID, DWORD dwFlags,
+ LPMCI_GETDEVCAPS_PARMS lpParms)
+{
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciGetDevCaps(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (dwFlags & MCI_GETDEVCAPS_ITEM) {
+ printf("CDAUDIO_mciGetDevCaps // MCI_GETDEVCAPS_ITEM dwItem=%08X);\n",
+ lpParms->dwItem);
+ switch(lpParms->dwItem) {
+ case MCI_GETDEVCAPS_CAN_RECORD:
+ lpParms->dwReturn = FALSE;
+ break;
+ case MCI_GETDEVCAPS_HAS_AUDIO:
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_GETDEVCAPS_HAS_VIDEO:
+ lpParms->dwReturn = FALSE;
+ break;
+ case MCI_GETDEVCAPS_DEVICE_TYPE:
+ lpParms->dwReturn = MCI_DEVTYPE_CD_AUDIO;
+ break;
+ case MCI_GETDEVCAPS_USES_FILES:
+ lpParms->dwReturn = FALSE;
+ break;
+ case MCI_GETDEVCAPS_COMPOUND_DEVICE:
+ lpParms->dwReturn = FALSE;
+ break;
+ case MCI_GETDEVCAPS_CAN_EJECT:
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_GETDEVCAPS_CAN_PLAY:
+ lpParms->dwReturn = TRUE;
+ break;
+ case MCI_GETDEVCAPS_CAN_SAVE:
+ lpParms->dwReturn = FALSE;
+ break;
+ default:
+ return MCIERR_UNRECOGNIZED_COMMAND;
+ }
+ }
+ printf("CDAUDIO_mciGetDevCaps // lpParms->dwReturn=%08X);\n", lpParms->dwReturn);
+ return 0;
+}
+
+/**************************************************************************
+* CDAUDIO_mciInfo [internal]
+*/
+DWORD CDAUDIO_mciInfo(UINT wDevID, DWORD dwFlags, LPMCI_INFO_PARMS lpParms)
+{
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciInfo(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ lpParms->lpstrReturn = NULL;
+ switch(dwFlags) {
+ case MCI_INFO_PRODUCT:
+ lpParms->lpstrReturn = "Linux CDROM 0.5";
+ break;
+ default:
+ return MCIERR_UNRECOGNIZED_COMMAND;
+ }
+ if (lpParms->lpstrReturn != NULL)
+ lpParms->dwRetSize = strlen(lpParms->lpstrReturn);
+ else
+ lpParms->dwRetSize = 0;
+ return 0;
+}
+
+/**************************************************************************
+* CDAUDIO_mciStatus [internal]
+*/
+DWORD CDAUDIO_mciStatus(UINT wDevID, DWORD dwFlags, LPMCI_STATUS_PARMS lpParms)
+{
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciStatus(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (CDADev[wDevID].unixdev == 0) return MMSYSERR_NOTENABLED;
+ if (dwFlags & MCI_NOTIFY) {
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciStatus // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+#endif
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ if (dwFlags & MCI_STATUS_ITEM) {
+ switch(lpParms->dwItem) {
+ case MCI_STATUS_CURRENT_TRACK:
+ if (!CDAUDIO_GetCDStatus(wDevID)) return MCIERR_INTERNAL;
+ lpParms->dwReturn = CDADev[wDevID].nCurTrack;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciStatus // CURRENT_TRACK=%u!\n", lpParms->dwReturn);
+#endif
+ return 0;
+ case MCI_STATUS_LENGTH:
+ if (CDADev[wDevID].nTracks == 0) {
+ if (!CDAUDIO_GetTracksInfo(wDevID)) {
+ printf("CDAUDIO_mciStatus // error reading TracksInfo !\n");
+ return MCIERR_INTERNAL;
+ }
+ }
+ if (dwFlags & MCI_TRACK) {
+ printf("CDAUDIO_mciStatus // MCI_TRACK #%u LENGTH=??? !\n",
+ lpParms->dwTrack);
+ if (lpParms->dwTrack > CDADev[wDevID].nTracks)
+ return MCIERR_OUTOFRANGE;
+ lpParms->dwReturn = CDADev[wDevID].lpdwTrackLen[lpParms->dwTrack];
+ }
+ else
+ lpParms->dwReturn = CDADev[wDevID].dwTotalLen;
+ lpParms->dwReturn = CDAUDIO_CalcTime(wDevID,
+ CDADev[wDevID].dwTimeFormat, lpParms->dwReturn);
+ printf("CDAUDIO_mciStatus // LENGTH=%u !\n", lpParms->dwReturn);
+ return 0;
+ case MCI_STATUS_MODE:
+ if (!CDAUDIO_GetCDStatus(wDevID)) return MCIERR_INTERNAL;
+ lpParms->dwReturn = CDADev[wDevID].mode;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciStatus // MCI_STATUS_MODE=%08X !\n",
+ lpParms->dwReturn);
+#endif
+ return 0;
+ case MCI_STATUS_MEDIA_PRESENT:
+ lpParms->dwReturn = (CDADev[wDevID].nTracks > 0) ? TRUE : FALSE;
+ if (lpParms->dwReturn == FALSE)
+ printf("CDAUDIO_mciStatus // MEDIA_NOT_PRESENT !\n");
+ else
+ printf("CDAUDIO_mciStatus // MCI_STATUS_MEDIA_PRESENT !\n");
+ return 0;
+ case MCI_STATUS_NUMBER_OF_TRACKS:
+ lpParms->dwReturn = CDAUDIO_GetNumberOfTracks(wDevID);
+ printf("CDAUDIO_mciStatus // MCI_STATUS_NUMBER_OF_TRACKS = %u !\n",
+ lpParms->dwReturn);
+ if (lpParms->dwReturn == (WORD)-1) return MCIERR_INTERNAL;
+ return 0;
+ case MCI_STATUS_POSITION:
+ if (!CDAUDIO_GetCDStatus(wDevID)) return MCIERR_INTERNAL;
+ lpParms->dwReturn = CDADev[wDevID].dwCurFrame;
+ if (dwFlags & MCI_STATUS_START) {
+ lpParms->dwReturn = CDADev[wDevID].dwFirstOffset;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciStatus // get MCI_STATUS_START !\n");
+#endif
+ }
+ if (dwFlags & MCI_TRACK) {
+ if (lpParms->dwTrack > CDADev[wDevID].nTracks)
+ return MCIERR_OUTOFRANGE;
+ lpParms->dwReturn = CDADev[wDevID].lpdwTrackPos[lpParms->dwTrack - 1];
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciStatus // get MCI_TRACK #%u !\n", lpParms->dwTrack);
+#endif
+ }
+ lpParms->dwReturn = CDAUDIO_CalcTime(wDevID,
+ CDADev[wDevID].dwTimeFormat, lpParms->dwReturn);
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciStatus // MCI_STATUS_POSITION=%08X !\n",
+ lpParms->dwReturn);
+#endif
+ return 0;
+ case MCI_STATUS_READY:
+ printf("CDAUDIO_mciStatus // MCI_STATUS_READY !\n");
+ lpParms->dwReturn = TRUE;
+ return 0;
+ case MCI_STATUS_TIME_FORMAT:
+ printf("CDAUDIO_mciStatus // MCI_STATUS_TIME_FORMAT !\n");
+ lpParms->dwReturn = MCI_FORMAT_MILLISECONDS;
+ return 0;
+ default:
+ printf("CDAUDIO_mciStatus // unknowm command %04X !\n", lpParms->dwItem);
+ return MCIERR_UNRECOGNIZED_COMMAND;
+ }
+ }
+ printf("CDAUDIO_mciStatus // not MCI_STATUS_ITEM !\n");
+ return 0;
+}
+
+
+/**************************************************************************
+* CDAUDIO_CalcTime [internal]
+*/
+DWORD CDAUDIO_CalcTime(UINT wDevID, DWORD dwFormatType, DWORD dwFrame)
+{
+ DWORD dwTime = 0;
+ UINT wTrack;
+ UINT wMinutes;
+ UINT wSeconds;
+ UINT wFrames;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_CalcTime(%u, %08X, %lu);\n", wDevID, dwFormatType, dwFrame);
+#endif
+TryAGAIN:
+ switch (dwFormatType) {
+ case MCI_FORMAT_MILLISECONDS:
+ dwTime = dwFrame / CDFRAMES_PERSEC * 1000;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_CalcTime // MILLISECONDS %u\n", dwTime);
+#endif
+ break;
+ case MCI_FORMAT_MSF:
+ wMinutes = dwFrame / CDFRAMES_PERMIN;
+ wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC;
+ wFrames = dwFrame - CDFRAMES_PERMIN * wMinutes -
+ CDFRAMES_PERSEC * wSeconds;
+ dwTime = MCI_MAKE_MSF(wMinutes, wSeconds, wFrames);
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_CalcTime // MSF %02u:%02u:%02u -> dwTime=%u\n",
+ wMinutes, wSeconds, wFrames, dwTime);
+#endif
+ break;
+ case MCI_FORMAT_TMSF:
+ for (wTrack = 0; wTrack < CDADev[wDevID].nTracks; wTrack++) {
+/* dwTime += CDADev[wDevID].lpdwTrackLen[wTrack - 1];
+ printf("Adding trk#%u curpos=%u \n", dwTime);
+ if (dwTime >= dwFrame) break; */
+ if (CDADev[wDevID].lpdwTrackPos[wTrack - 1] >= dwFrame) break;
+ }
+ wMinutes = dwFrame / CDFRAMES_PERMIN;
+ wSeconds = (dwFrame - CDFRAMES_PERMIN * wMinutes) / CDFRAMES_PERSEC;
+ wFrames = dwFrame - CDFRAMES_PERMIN * wMinutes -
+ CDFRAMES_PERSEC * wSeconds;
+ dwTime = MCI_MAKE_TMSF(wTrack, wMinutes, wSeconds, wFrames);
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_CalcTime // %02u-%02u:%02u:%02u\n",
+ wTrack, wMinutes, wSeconds, wFrames);
+#endif
+ break;
+ default:
+ /* unknown format ! force TMSF ! ... */
+ dwFormatType = MCI_FORMAT_TMSF;
+ goto TryAGAIN;
+ }
+ return dwTime;
+}
+
+
+/**************************************************************************
+* CDAUDIO_CalcFrame [internal]
+*/
+DWORD CDAUDIO_CalcFrame(UINT wDevID, DWORD dwFormatType, DWORD dwTime)
+{
+ DWORD dwFrame = 0;
+ UINT wTrack;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_CalcFrame(%u, %08X, %lu);\n", wDevID, dwFormatType, dwTime);
+#endif
+TryAGAIN:
+ switch (dwFormatType) {
+ case MCI_FORMAT_MILLISECONDS:
+ dwFrame = dwTime * CDFRAMES_PERSEC / 1000;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_CalcFrame // MILLISECONDS %u\n", dwFrame);
+#endif
+ break;
+ case MCI_FORMAT_MSF:
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_CalcFrame // MSF %02u:%02u:%02u\n",
+ MCI_MSF_MINUTE(dwTime), MCI_MSF_SECOND(dwTime),
+ MCI_MSF_FRAME(dwTime));
+#endif
+ dwFrame += CDFRAMES_PERMIN * MCI_MSF_MINUTE(dwTime);
+ dwFrame += CDFRAMES_PERSEC * MCI_MSF_SECOND(dwTime);
+ dwFrame += MCI_MSF_FRAME(dwTime);
+ break;
+ case MCI_FORMAT_TMSF:
+ wTrack = MCI_TMSF_TRACK(dwTime);
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_CalcFrame // TMSF %02u-%02u:%02u:%02u\n",
+ MCI_TMSF_TRACK(dwTime), MCI_TMSF_MINUTE(dwTime),
+ MCI_TMSF_SECOND(dwTime), MCI_TMSF_FRAME(dwTime));
+ printf("CDAUDIO_CalcFrame // TMSF trackpos[%u]=%u\n",
+ wTrack, CDADev[wDevID].lpdwTrackPos[wTrack - 1]);
+#endif
+ dwFrame = CDADev[wDevID].lpdwTrackPos[wTrack - 1];
+ dwFrame += CDFRAMES_PERMIN * MCI_TMSF_MINUTE(dwTime);
+ dwFrame += CDFRAMES_PERSEC * MCI_TMSF_SECOND(dwTime);
+ dwFrame += MCI_TMSF_FRAME(dwTime);
+ break;
+ default:
+ /* unknown format ! force TMSF ! ... */
+ dwFormatType = MCI_FORMAT_TMSF;
+ goto TryAGAIN;
+ }
+ return dwFrame;
+}
+
+
+/**************************************************************************
+* CDAUDIO_GetNumberOfTracks [internal]
+*/
+UINT CDAUDIO_GetNumberOfTracks(UINT wDevID)
+{
+ struct cdrom_tochdr hdr;
+ if (CDADev[wDevID].nTracks == 0) {
+ if (ioctl(CDADev[wDevID].unixdev, CDROMREADTOCHDR, &hdr)) {
+ printf("GetNumberOfTracks(%u) // Error occured !\n", wDevID);
+ return (WORD)-1;
+ }
+ CDADev[wDevID].nTracks = hdr.cdth_trk1;
+ }
+ return CDADev[wDevID].nTracks;
+}
+
+/**************************************************************************
+* CDAUDIO_GetNumberOfTracks [internal]
+*/
+BOOL CDAUDIO_GetTracksInfo(UINT wDevID)
+{
+ int i, length;
+ int start, last_start;
+ int total_length = 0;
+ struct cdrom_tocentry entry;
+ if (CDADev[wDevID].nTracks == 0) {
+ if (CDAUDIO_GetNumberOfTracks(wDevID) == (WORD)-1) return FALSE;
+ }
+ if (CDADev[wDevID].lpdwTrackLen != NULL)
+ free(CDADev[wDevID].lpdwTrackLen);
+ CDADev[wDevID].lpdwTrackLen = (LPDWORD)malloc(
+ (CDADev[wDevID].nTracks + 1) * sizeof(DWORD));
+ if (CDADev[wDevID].lpdwTrackPos != NULL)
+ free(CDADev[wDevID].lpdwTrackPos);
+ CDADev[wDevID].lpdwTrackPos = (LPDWORD)malloc(
+ (CDADev[wDevID].nTracks + 1) * sizeof(DWORD));
+ if (CDADev[wDevID].lpdwTrackLen == NULL ||
+ CDADev[wDevID].lpdwTrackPos == NULL) {
+ printf("CDAUDIO_GetTracksInfo // error allocating track table !\n");
+ return FALSE;
+ }
+ memset(CDADev[wDevID].lpdwTrackLen, 0,
+ (CDADev[wDevID].nTracks + 1) * sizeof(DWORD));
+ memset(CDADev[wDevID].lpdwTrackPos, 0,
+ (CDADev[wDevID].nTracks + 1) * sizeof(DWORD));
+ for (i = 0; i <= CDADev[wDevID].nTracks; i++) {
+ if (i == CDADev[wDevID].nTracks)
+ entry.cdte_track = CDROM_LEADOUT;
+ else
+ entry.cdte_track = i + 1;
+ entry.cdte_format = CDROM_MSF;
+ if (ioctl(CDADev[wDevID].unixdev, CDROMREADTOCENTRY, &entry)) {
+ printf("CDAUDIO_GetTracksInfo // error read entry\n");
+ return FALSE;
+ }
+ start = CDFRAMES_PERSEC * (SECONDS_PERMIN *
+ entry.cdte_addr.msf.minute + entry.cdte_addr.msf.second) +
+ entry.cdte_addr.msf.frame;
+ if (i == 0) {
+ CDADev[wDevID].dwFirstOffset = last_start = start;
+ printf("CDAUDIO_GetTracksInfo // dwFirstOffset=%u\n", start);
+ }
+ else {
+ length = start - last_start;
+ last_start = start;
+ start = last_start - length;
+ total_length += length;
+ CDADev[wDevID].lpdwTrackLen[i - 1] = length;
+ CDADev[wDevID].lpdwTrackPos[i - 1] = start;
+ printf("CDAUDIO_GetTracksInfo // track #%u start=%u len=%u\n",
+ i, start, length);
+ }
+ }
+ CDADev[wDevID].dwTotalLen = total_length;
+ printf("CDAUDIO_GetTracksInfo // total_len=%u\n", total_length);
+ return TRUE;
+}
+
+
+/**************************************************************************
+* CDAUDIO_GetNumberOfTracks [internal]
+*/
+BOOL CDAUDIO_GetCDStatus(UINT wDevID)
+{
+ int oldmode = CDADev[wDevID].mode;
+ CDADev[wDevID].sc.cdsc_format = CDROM_MSF;
+ if (ioctl(CDADev[wDevID].unixdev, CDROMSUBCHNL, &CDADev[wDevID].sc)) {
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_GetCDStatus // opened or no_media !\n");
+#endif
+ CDADev[wDevID].mode = MCI_MODE_OPEN;
+ return TRUE;
+ }
+ switch (CDADev[wDevID].sc.cdsc_audiostatus) {
+ case CDROM_AUDIO_INVALID:
+ printf("CDAUDIO_GetCDStatus // device doesn't support status !\n");
+ return FALSE;
+ case CDROM_AUDIO_NO_STATUS:
+ CDADev[wDevID].mode = MCI_MODE_STOP;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_GetCDStatus // MCI_MODE_STOP !\n");
+#endif
+ break;
+ case CDROM_AUDIO_PLAY:
+ CDADev[wDevID].mode = MCI_MODE_PLAY;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_GetCDStatus // MCI_MODE_PLAY !\n");
+#endif
+ break;
+ case CDROM_AUDIO_PAUSED:
+ CDADev[wDevID].mode = MCI_MODE_PAUSE;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_GetCDStatus // MCI_MODE_PAUSE !\n");
+#endif
+ break;
+ default:
+ printf("CDAUDIO_GetCDStatus // status=%02X !\n",
+ CDADev[wDevID].sc.cdsc_audiostatus);
+ }
+ CDADev[wDevID].nCurTrack = CDADev[wDevID].sc.cdsc_trk;
+ CDADev[wDevID].dwCurFrame =
+ CDFRAMES_PERMIN * CDADev[wDevID].sc.cdsc_absaddr.msf.minute +
+ CDFRAMES_PERSEC * CDADev[wDevID].sc.cdsc_absaddr.msf.second +
+ CDADev[wDevID].sc.cdsc_absaddr.msf.frame;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_GetCDStatus // %02u-%02u:%02u:%02u \n",
+ CDADev[wDevID].sc.cdsc_trk,
+ CDADev[wDevID].sc.cdsc_absaddr.msf.minute,
+ CDADev[wDevID].sc.cdsc_absaddr.msf.second,
+ CDADev[wDevID].sc.cdsc_absaddr.msf.frame);
+#endif
+ if (oldmode != CDADev[wDevID].mode && oldmode == MCI_MODE_OPEN) {
+ if (!CDAUDIO_GetTracksInfo(wDevID)) {
+ printf("CDAUDIO_GetCDStatus // error updating TracksInfo !\n");
+ return MCIERR_INTERNAL;
+ }
+ }
+ return TRUE;
+}
+
+/**************************************************************************
+* CDAUDIO_mciPlay [internal]
+*/
+DWORD CDAUDIO_mciPlay(UINT wDevID, DWORD dwFlags, LPMCI_PLAY_PARMS lpParms)
+{
+ int start, end;
+ struct cdrom_msf msf;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciPlay(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (CDADev[wDevID].unixdev == 0) return MMSYSERR_NOTENABLED;
+ start = 0; end = CDADev[wDevID].dwTotalLen;
+ CDADev[wDevID].nCurTrack = 1;
+ if (dwFlags & MCI_FROM) {
+ start = CDAUDIO_CalcFrame(wDevID,
+ CDADev[wDevID].dwTimeFormat, lpParms->dwFrom);
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciPlay // MCI_FROM=%08X -> %u \n",
+ lpParms->dwFrom, start);
+#endif
+ }
+ if (dwFlags & MCI_TO) {
+ end = CDAUDIO_CalcFrame(wDevID,
+ CDADev[wDevID].dwTimeFormat, lpParms->dwTo);
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciPlay // MCI_TO=%08X -> %u \n",
+ lpParms->dwTo, end);
+#endif
+ }
+ start += CDADev[wDevID].dwFirstOffset;
+ end += CDADev[wDevID].dwFirstOffset;
+ msf.cdmsf_min0 = start / CDFRAMES_PERMIN;
+ msf.cdmsf_sec0 = (start % CDFRAMES_PERMIN) / CDFRAMES_PERSEC;
+ msf.cdmsf_frame0 = start % CDFRAMES_PERSEC;
+ msf.cdmsf_min1 = end / CDFRAMES_PERMIN;
+ msf.cdmsf_sec1 = (end % CDFRAMES_PERMIN) / CDFRAMES_PERSEC;
+ msf.cdmsf_frame1 = end % CDFRAMES_PERSEC;
+ if (ioctl(CDADev[wDevID].unixdev, CDROMSTART)) {
+ printf("CDAUDIO_mciPlay // motor doesn't start !\n");
+ return MCIERR_HARDWARE;
+ }
+ if (ioctl(CDADev[wDevID].unixdev, CDROMPLAYMSF, &msf)) {
+ printf("CDAUDIO_mciPlay // device doesn't play !\n");
+ return MCIERR_HARDWARE;
+ }
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciPlay // msf = %d:%d:%d %d:%d:%d\n",
+ msf.cdmsf_min0, msf.cdmsf_sec0, msf.cdmsf_frame0,
+ msf.cdmsf_min1, msf.cdmsf_sec1, msf.cdmsf_frame1);
+#endif
+ CDADev[wDevID].mode = MCI_MODE_PLAY;
+ if (dwFlags & MCI_NOTIFY) {
+ printf("CDAUDIO_mciPlay // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+/**************************************************************************
+* CDAUDIO_mciStop [internal]
+*/
+DWORD CDAUDIO_mciStop(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
+{
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciStop(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (ioctl(CDADev[wDevID].unixdev, CDROMSTOP)) return MCIERR_HARDWARE;
+ CDADev[wDevID].mode = MCI_MODE_STOP;
+ if (dwFlags & MCI_NOTIFY) {
+ printf("CDAUDIO_mciStop // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+/**************************************************************************
+* CDAUDIO_mciPause [internal]
+*/
+DWORD CDAUDIO_mciPause(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
+{
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciPause(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (ioctl(CDADev[wDevID].unixdev, CDROMPAUSE)) return MCIERR_HARDWARE;
+ CDADev[wDevID].mode = MCI_MODE_PAUSE;
+ if (dwFlags & MCI_NOTIFY) {
+ printf("CDAUDIO_mciPause // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+/**************************************************************************
+* CDAUDIO_mciResume [internal]
+*/
+DWORD CDAUDIO_mciResume(UINT wDevID, DWORD dwFlags, LPMCI_GENERIC_PARMS lpParms)
+{
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciResume(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (ioctl(CDADev[wDevID].unixdev, CDROMRESUME)) return MCIERR_HARDWARE;
+ CDADev[wDevID].mode = MCI_MODE_STOP;
+ if (dwFlags & MCI_NOTIFY) {
+ printf("CDAUDIO_mciResume // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+/**************************************************************************
+* CDAUDIO_mciSeek [internal]
+*/
+DWORD CDAUDIO_mciSeek(UINT wDevID, DWORD dwFlags, LPMCI_SEEK_PARMS lpParms)
+{
+ DWORD dwRet;
+ MCI_PLAY_PARMS PlayParms;
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciSeek(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+ if (ioctl(CDADev[wDevID].unixdev, CDROMRESUME)) return MCIERR_HARDWARE;
+ CDADev[wDevID].mode = MCI_MODE_SEEK;
+ switch(dwFlags) {
+ case MCI_SEEK_TO_START:
+ PlayParms.dwFrom = 0;
+ break;
+ case MCI_SEEK_TO_END:
+ PlayParms.dwFrom = CDADev[wDevID].dwTotalLen;
+ break;
+ case MCI_TO:
+ PlayParms.dwFrom = lpParms->dwTo;
+ break;
+ }
+ dwRet = CDAUDIO_mciPlay(wDevID, MCI_WAIT | MCI_FROM, &PlayParms);
+ if (dwRet != 0) return dwRet;
+ dwRet = CDAUDIO_mciStop(wDevID, MCI_WAIT, (LPMCI_GENERIC_PARMS)&PlayParms);
+ if (dwFlags & MCI_NOTIFY) {
+ printf("CDAUDIO_mciSeek // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return dwRet;
+}
+
+
+/**************************************************************************
+* CDAUDIO_mciSet [internal]
+*/
+DWORD CDAUDIO_mciSet(UINT wDevID, DWORD dwFlags, LPMCI_SET_PARMS lpParms)
+{
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciSet(%u, %08X, %08X);\n", wDevID, dwFlags, lpParms);
+#endif
+ if (lpParms == NULL) return MCIERR_INTERNAL;
+/*
+ printf("CDAUDIO_mciSet // dwTimeFormat=%08X\n", lpParms->dwTimeFormat);
+ printf("CDAUDIO_mciSet // dwAudio=%08X\n", lpParms->dwAudio);
+*/
+ if (dwFlags & MCI_SET_TIME_FORMAT) {
+ switch (lpParms->dwTimeFormat) {
+ case MCI_FORMAT_MILLISECONDS:
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciSet // MCI_FORMAT_MILLISECONDS !\n");
+#endif
+ break;
+ case MCI_FORMAT_MSF:
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciSet // MCI_FORMAT_MSF !\n");
+#endif
+ break;
+ case MCI_FORMAT_TMSF:
+#ifdef DEBUG_CDAUDIO
+ printf("CDAUDIO_mciSet // MCI_FORMAT_TMSF !\n");
+#endif
+ break;
+ default:
+ printf("CDAUDIO_mciSet // bad time format !\n");
+ return MCIERR_BAD_TIME_FORMAT;
+ }
+ CDADev[wDevID].dwTimeFormat = lpParms->dwTimeFormat;
+ }
+ if (dwFlags & MCI_SET_DOOR_OPEN) {
+ printf("CDAUDIO_mciSet // MCI_SET_DOOR_OPEN !\n");
+ if (ioctl(CDADev[wDevID].unixdev, CDROMEJECT)) return MCIERR_HARDWARE;
+ CDADev[wDevID].nTracks = 0;
+ }
+ if (dwFlags & MCI_SET_DOOR_CLOSED) {
+ printf("CDAUDIO_mciSet // MCI_SET_DOOR_CLOSED !\n");
+ if (ioctl(CDADev[wDevID].unixdev, CDROMEJECT)) return MCIERR_HARDWARE;
+ CDADev[wDevID].nTracks = 0;
+ }
+ if (dwFlags & MCI_SET_VIDEO) return MCIERR_UNSUPPORTED_FUNCTION;
+ if (dwFlags & MCI_SET_ON) return MCIERR_UNSUPPORTED_FUNCTION;
+ if (dwFlags & MCI_SET_OFF) return MCIERR_UNSUPPORTED_FUNCTION;
+ if (dwFlags & MCI_NOTIFY) {
+ printf("CDAUDIO_mciSet // MCI_NOTIFY_SUCCESSFUL %08X !\n", lpParms->dwCallback);
+ mciDriverNotify((HWND)LOWORD(lpParms->dwCallback),
+ CDADev[wDevID].wNotifyDeviceID, MCI_NOTIFY_SUCCESSFUL);
+ }
+ return 0;
+}
+
+
+/**************************************************************************
+* CDAUDIO_DriverProc [sample driver]
+*/
+LRESULT CDAUDIO_DriverProc(DWORD dwDevID, HDRVR hDriv, WORD wMsg,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ switch(wMsg) {
+ case DRV_LOAD:
+ return (LRESULT)1L;
+ case DRV_FREE:
+ return (LRESULT)1L;
+ case DRV_OPEN:
+ case MCI_OPEN_DRIVER:
+ case MCI_OPEN:
+ return CDAUDIO_mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
+ case DRV_CLOSE:
+ case MCI_CLOSE_DRIVER:
+ case MCI_CLOSE:
+ return CDAUDIO_mciClose(dwDevID, dwParam1,
+ (LPMCI_GENERIC_PARMS)dwParam2);
+ case DRV_ENABLE:
+ return (LRESULT)1L;
+ case DRV_DISABLE:
+ return (LRESULT)1L;
+ case DRV_QUERYCONFIGURE:
+ return (LRESULT)1L;
+ case DRV_CONFIGURE:
+ MessageBox((HWND)NULL, "Sample MultiMedia Linux Driver !",
+ "MMLinux Driver", MB_OK);
+ return (LRESULT)1L;
+ case DRV_INSTALL:
+ return (LRESULT)DRVCNF_RESTART;
+ case DRV_REMOVE:
+ return (LRESULT)DRVCNF_RESTART;
+ case MCI_GETDEVCAPS:
+ return CDAUDIO_mciGetDevCaps(dwDevID, dwParam1,
+ (LPMCI_GETDEVCAPS_PARMS)dwParam2);
+ case MCI_INFO:
+ return CDAUDIO_mciInfo(dwDevID, dwParam1,
+ (LPMCI_INFO_PARMS)dwParam2);
+ case MCI_STATUS:
+ return CDAUDIO_mciStatus(dwDevID, dwParam1,
+ (LPMCI_STATUS_PARMS)dwParam2);
+ case MCI_SET:
+ return CDAUDIO_mciSet(dwDevID, dwParam1,
+ (LPMCI_SET_PARMS)dwParam2);
+ case MCI_PLAY:
+ return CDAUDIO_mciPlay(dwDevID, dwParam1,
+ (LPMCI_PLAY_PARMS)dwParam2);
+ case MCI_STOP:
+ return CDAUDIO_mciStop(dwDevID, dwParam1,
+ (LPMCI_GENERIC_PARMS)dwParam2);
+ case MCI_PAUSE:
+ return CDAUDIO_mciPause(dwDevID, dwParam1,
+ (LPMCI_GENERIC_PARMS)dwParam2);
+ case MCI_RESUME:
+ return CDAUDIO_mciResume(dwDevID, dwParam1,
+ (LPMCI_GENERIC_PARMS)dwParam2);
+ case MCI_SEEK:
+ return CDAUDIO_mciSeek(dwDevID, dwParam1,
+ (LPMCI_SEEK_PARMS)dwParam2);
+ case MCI_SET_DOOR_OPEN:
+ printf("CDAUDIO_DriverProc // MCI_SET_DOOR_OPEN !\n");
+ if (ioctl(CDADev[dwDevID].unixdev, CDROMEJECT)) return MCIERR_HARDWARE;
+ CDADev[dwDevID].nTracks = 0;
+ return 0;
+ case MCI_SET_DOOR_CLOSED:
+ printf("CDAUDIO_DriverProc // MCI_SET_DOOR_CLOSED !\n");
+ if (ioctl(CDADev[dwDevID].unixdev, CDROMEJECT, 1)) return MCIERR_HARDWARE;
+ CDADev[dwDevID].nTracks = 0;
+ return 0;
+ default:
+ return DefDriverProc(dwDevID, hDriv, wMsg, dwParam1, dwParam2);
+ }
+}
+
+
+/*-----------------------------------------------------------------------*/
+
diff --git a/misc/mmaux.c b/misc/mmaux.c
new file mode 100644
index 0000000..64627d8
--- /dev/null
+++ b/misc/mmaux.c
@@ -0,0 +1,116 @@
+/*
+ * Sample AUXILARY Wine Driver for Linux
+ *
+ * Copyright 1994 Martin Ayotte
+ */
+
+static char Copyright[] = "Copyright Martin Ayotte, 1994";
+
+#include "stdio.h"
+#include "win.h"
+#include "user.h"
+#include "driver.h"
+#include "mmsystem.h"
+
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <linux/soundcard.h>
+
+#define SOUND_DEV "/dev/dsp"
+#define MIXER_DEV "/dev/mixer"
+
+#ifdef SOUND_VERSION
+#define IOCTL(a,b,c) ioctl(a,b,&c)
+#else
+#define IOCTL(a,b,c) (c = ioctl(a,b,c) )
+#endif
+
+
+/*-----------------------------------------------------------------------*/
+
+
+/**************************************************************************
+* AUX_GetDevCaps [internal]
+*/
+DWORD AUX_GetDevCaps(WORD wDevID, LPAUXCAPS lpCaps, DWORD dwSize)
+{
+ int mixer;
+ int volume;
+ printf("AUX_GetDevCaps(%u, %08X, %u);\n", wDevID, lpCaps, dwSize);
+ if (lpCaps == NULL) return MMSYSERR_NOTENABLED;
+ if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) {
+ printf("AUX_GetDevCaps // mixer device not available !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (ioctl(mixer, SOUND_MIXER_READ_LINE, &volume) == -1) {
+ printf("AUX_GetDevCaps // unable read mixer !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ close(mixer);
+ return MMSYSERR_NOERROR;
+}
+
+
+/**************************************************************************
+* AUX_GetVolume [internal]
+*/
+DWORD AUX_GetVolume(WORD wDevID, DWORD dwParam)
+{
+ int mixer;
+ int volume;
+ printf("AUX_GetVolume(%u, %08X);\n", wDevID, dwParam);
+ if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) {
+ printf("Linux 'AUX_GetVolume' // mixer device not available !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (ioctl(mixer, SOUND_MIXER_READ_LINE, &volume) == -1) {
+ printf("Linux 'AUX_GetVolume' // unable read mixer !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ close(mixer);
+ return MMSYSERR_NOERROR;
+}
+
+/**************************************************************************
+* AUX_SetVolume [internal]
+*/
+DWORD AUX_SetVolume(WORD wDevID, DWORD dwParam)
+{
+ int mixer;
+ int volume = 50;
+ printf("AUX_SetVolume(%u, %08X);\n", wDevID, dwParam);
+ if ((mixer = open(MIXER_DEV, O_RDWR)) < 0) {
+ printf("Linux 'AUX_SetVolume' // mixer device not available !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ if (ioctl(mixer, SOUND_MIXER_WRITE_LINE, &volume) == -1) {
+ printf("Linux 'AUX_SetVolume' // unable set mixer !\n");
+ return MMSYSERR_NOTENABLED;
+ }
+ close(mixer);
+ return MMSYSERR_NOERROR;
+}
+
+
+/**************************************************************************
+* auxMessage [sample driver]
+*/
+DWORD auxMessage(WORD wDevID, WORD wMsg, DWORD dwUser,
+ DWORD dwParam1, DWORD dwParam2)
+{
+ printf("auxMessage(%u, %04X, %08X, %08X, %08X);\n",
+ wDevID, wMsg, dwUser, dwParam1, dwParam2);
+ switch(wMsg) {
+ case AUXDM_GETDEVCAPS:
+ return AUX_GetDevCaps(wDevID, (LPAUXCAPS)dwParam1, dwParam2);
+ case AUXDM_GETNUMDEVS:
+ return 0L;
+ case AUXDM_GETVOLUME:
+ return AUX_GetVolume(wDevID, dwParam1);
+ case AUXDM_SETVOLUME:
+ return AUX_SetVolume(wDevID, dwParam1);
+ }
+ return MMSYSERR_NOTSUPPORTED;
+}
+
+
diff --git a/misc/mmsystem.c b/misc/mmsystem.c
index 90fc2de..da5ad6f 100644
--- a/misc/mmsystem.c
+++ b/misc/mmsystem.c
@@ -7,7 +7,10 @@
static char Copyright[] = "Copyright Martin Ayotte, 1993";
#include "stdio.h"
+#include <fcntl.h>
+#include <sys/ioctl.h>
#include "win.h"
+#include "user.h"
#include "driver.h"
#include "mmsystem.h"
@@ -31,6 +34,8 @@
static LPTIMERENTRY lpTimerList = NULL;
+static MCI_OPEN_DRIVER_PARMS mciDrv[MAXMCIDRIVERS];
+
UINT WINAPI midiGetErrorText(UINT uError, LPSTR lpText, UINT uSize);
UINT WINAPI waveGetErrorText(UINT uError, LPSTR lpText, UINT uSize);
@@ -50,9 +55,67 @@
*/
BOOL WINAPI sndPlaySound(LPCSTR lpszSoundName, UINT uFlags)
{
- printf("EMPTY STUB !!! sndPlaySound // SoundName='%s' uFlags=%04X !\n",
- lpszSoundName, uFlags);
- return 0;
+ int hFile;
+ int count;
+ WAVEHDR WaveHdr;
+ PCMWAVEFORMAT WaveFormat;
+ WAVEOPENDESC WaveDesc;
+ DWORD dwRet;
+ char str[128];
+ LPSTR ptr;
+ printf("sndPlaySound // SoundName='%s' uFlags=%04X !\n",
+ lpszSoundName, uFlags);
+ if (lpszSoundName == NULL) {
+ printf("sndPlaySound // Stop !\n");
+ return FALSE;
+ }
+ hFile = open(lpszSoundName, O_RDONLY);
+ if (hFile == 0) {
+ printf("sndPlaySound // searching in SystemSound List !\n");
+ GetProfileString("Sounds", (LPSTR)lpszSoundName, "", str, sizeof(str));
+ if (strlen(str) == 0) return FALSE;
+ if ((ptr = strchr(str, ',')) != NULL) *ptr = '\0';
+ hFile = open(str, O_RDONLY);
+ if (hFile == 0) {
+ printf("sndPlaySound // can't find SystemSound='%s' !\n", str);
+ return FALSE;
+ }
+ }
+ WaveDesc.hWave = 0;
+ WaveDesc.lpFormat = (LPWAVEFORMAT)&WaveFormat;
+ WaveFormat.wf.wFormatTag = WAVE_FORMAT_PCM;
+ WaveFormat.wBitsPerSample = 8;
+ WaveFormat.wf.nChannels = 1;
+ WaveFormat.wf.nSamplesPerSec = 11025;
+ WaveFormat.wf.nAvgBytesPerSec = 11025;
+ WaveFormat.wf.nBlockAlign = 1;
+ dwRet = wodMessage(0, WODM_OPEN, 0, (DWORD)&WaveDesc, CALLBACK_NULL);
+ if (dwRet != MMSYSERR_NOERROR) {
+ printf("sndPlaySound // can't open WaveOut device !\n");
+ return FALSE;
+ }
+ WaveHdr.lpData = (LPSTR) malloc(64000);
+ WaveHdr.dwBufferLength = 64000;
+ WaveHdr.dwUser = 0L;
+ WaveHdr.dwFlags = 0L;
+ WaveHdr.dwLoops = 0L;
+ dwRet = wodMessage(0, WODM_PREPARE, 0, (DWORD)&WaveHdr, sizeof(WAVEHDR));
+ if (dwRet != MMSYSERR_NOERROR) {
+ printf("sndPlaySound // can't prepare WaveOut device !\n");
+ return FALSE;
+ }
+ while(TRUE) {
+ count = read(hFile, WaveHdr.lpData, WaveHdr.dwBufferLength);
+ if (count == 0) break;
+ WaveHdr.dwBytesRecorded = count;
+ wodMessage(0, WODM_WRITE, 0, (DWORD)&WaveHdr, sizeof(WAVEHDR));
+ }
+ wodMessage(0, WODM_UNPREPARE, 0, (DWORD)&WaveHdr, sizeof(WAVEHDR));
+ wodMessage(0, WODM_CLOSE, 0, 0L, 0L);
+ free(WaveHdr.lpData);
+ close(hFile);
+
+ return TRUE;
}
/**************************************************************************
@@ -87,7 +150,23 @@
BOOL DriverCallback(DWORD dwCallBack, UINT uFlags, HANDLE hDev,
WORD wMsg, DWORD dwUser, DWORD dwParam1, DWORD dwParam2)
{
- printf("EMPTY STUB !!! DriverCallback() !\n");
+ printf("DriverCallback(%08X, %04X, %04X, %04X, %08X, %08X, %08X); !\n",
+ dwCallBack, uFlags, hDev, wMsg, dwUser, dwParam1, dwParam2);
+ switch(uFlags & DCB_TYPEMASK) {
+ case DCB_NULL:
+ printf("DriverCallback() // CALLBACK_NULL !\n");
+ break;
+ case DCB_WINDOW:
+ printf("DriverCallback() // CALLBACK_WINDOW !\n");
+ break;
+ case DCB_TASK:
+ printf("DriverCallback() // CALLBACK_TASK !\n");
+ break;
+ case DCB_FUNCTION:
+ printf("DriverCallback() // CALLBACK_FUNCTION !\n");
+ break;
+ }
+ return TRUE;
}
/**************************************************************************
@@ -170,8 +249,11 @@
*/
UINT WINAPI auxGetNumDevs()
{
+ UINT count = 0;
printf("auxGetNumDevs !\n");
- return 0;
+ count += auxMessage(0, AUXDM_GETNUMDEVS, 0L, 0L, 0L);
+ printf("auxGetNumDevs return %u \n", count);
+ return count;
}
/**************************************************************************
@@ -474,25 +556,32 @@
/**************************************************************************
-* mciWaveOpen [internal]
+* mciDriverNotify [MMSYSTEM.711]
*/
-DWORD mciWaveOpen(UINT wDevID, DWORD dwParam, LPMCI_WAVE_OPEN_PARMS lpParms)
+BOOL WINAPI mciDriverNotify(HWND hWndCallBack, UINT wDevID, UINT wStatus)
{
- if (lpParms == NULL) return MCIERR_INTERNAL;
- printf("mciWaveOpen(%04X, %08X, %08X)\n", wDevID, dwParam, lpParms);
- return MCIERR_INTERNAL;
+ printf("mciDriverNotify(%04X, %u, %04X)\n", hWndCallBack, wDevID, wStatus);
+ PostMessage(hWndCallBack, MM_MCINOTIFY, wStatus,
+ MAKELONG(mciDrv[wDevID].wDeviceID, 0));
+ return TRUE;
}
-
/**************************************************************************
* mciOpen [internal]
*/
-DWORD mciOpen(UINT wDevID, DWORD dwParam, LPMCI_OPEN_PARMS lpParms)
+DWORD mciOpen(DWORD dwParam, LPMCI_OPEN_PARMS lpParms)
{
char str[128];
DWORD dwDevTyp = 0;
+ UINT wDevID = 1;
+ printf("mciOpen(%08X, %08X)\n", dwParam, lpParms);
if (lpParms == NULL) return MCIERR_INTERNAL;
- printf("mciOpen(%04X, %08X, %08X)\n", wDevID, dwParam, lpParms);
+ while(mciDrv[wDevID].wType != 0) {
+ if (++wDevID >= MAXMCIDRIVERS) {
+ printf("MCI_OPEN // MAXMCIDRIVERS reached !\n");
+ return MCIERR_INTERNAL;
+ }
+ }
if (dwParam & MCI_OPEN_TYPE) {
if (lpParms->lpstrDeviceType == NULL) return MCIERR_INTERNAL;
if (dwParam & MCI_OPEN_TYPE_ID) {
@@ -519,13 +608,17 @@
dwDevTyp = MCI_DEVTYPE_ANIMATION;
}
}
+ mciDrv[wDevID].wType = dwDevTyp;
+ mciDrv[wDevID].wDeviceID = 1;
+ lpParms->wDeviceID = wDevID;
+ printf("MCI_OPEN // wDeviceID=%04X !\n", lpParms->wDeviceID);
switch(dwDevTyp) {
case MCI_DEVTYPE_CD_AUDIO:
- printf("MCI_OPEN // No SEQUENCER yet !\n");
- return MCIERR_DEVICE_NOT_INSTALLED;
+ return CDAUDIO_DriverProc(0, 0, MCI_OPEN_DRIVER,
+ dwParam, (DWORD)lpParms);
case MCI_DEVTYPE_WAVEFORM_AUDIO:
- printf("MCI_OPEN // No WAVEAUDIO yet !\n");
- return MCIERR_DEVICE_NOT_INSTALLED;
+ return WAVE_DriverProc(0, 0, MCI_OPEN_DRIVER,
+ dwParam, (DWORD)lpParms);
case MCI_DEVTYPE_SEQUENCER:
printf("MCI_OPEN // No SEQUENCER yet !\n");
return MCIERR_DEVICE_NOT_INSTALLED;
@@ -539,19 +632,36 @@
printf("MCI_OPEN // Invalid Device Name '%08X' !\n", lpParms->lpstrDeviceType);
return MCIERR_INVALID_DEVICE_NAME;
}
- lpParms->wDeviceID = ++mciActiveDev;
- printf("MCI_OPEN // wDeviceID=%04X !\n", lpParms->wDeviceID);
- return 0;
- }
- if (dwParam & MCI_OPEN_ELEMENT) {
- printf("MCI_OPEN // Element !\n");
- printf("MCI_OPEN // Elem=%s' !\n", lpParms->lpstrElementName);
}
return MCIERR_INTERNAL;
}
/**************************************************************************
+* mciClose [internal]
+*/
+DWORD mciClose(UINT wDevID, DWORD dwParam, LPMCI_GENERIC_PARMS lpParms)
+{
+ DWORD dwRet = MCIERR_INTERNAL;
+ printf("mciClose(%u, %08X, %08X)\n", wDevID, dwParam, lpParms);
+ switch(mciDrv[wDevID].wType) {
+ case MCI_DEVTYPE_CD_AUDIO:
+ dwRet = CDAUDIO_DriverProc(mciDrv[wDevID].wDeviceID, 0,
+ MCI_CLOSE, dwParam, (DWORD)lpParms);
+ break;
+ case MCI_DEVTYPE_WAVEFORM_AUDIO:
+ dwRet = WAVE_DriverProc(mciDrv[wDevID].wDeviceID, 0,
+ MCI_CLOSE, dwParam, (DWORD)lpParms);
+ break;
+ default:
+ printf("mciClose() // unknown type=%04X !\n", mciDrv[wDevID].wType);
+ }
+ mciDrv[wDevID].wType = 0;
+ return dwRet;
+}
+
+
+/**************************************************************************
* mciSound [internal]
*/
DWORD mciSound(UINT wDevID, DWORD dwParam, LPMCI_SOUND_PARMS lpParms)
@@ -563,106 +673,36 @@
}
-/**************************************************************************
-* mciGetDevCaps [internal]
-*/
-DWORD mciGetDevCaps(UINT wDevID, DWORD dwParam, LPMCI_GETDEVCAPS_PARMS lpParms)
-{
- if (lpParms == NULL) return MCIERR_INTERNAL;
- lpParms->dwReturn = 0;
- return 0;
-}
-
-
-/**************************************************************************
-* mciInfo [internal]
-*/
-DWORD mciInfo(UINT wDevID, DWORD dwParam, LPMCI_INFO_PARMS lpParms)
-{
- if (lpParms == NULL) return MCIERR_INTERNAL;
- lpParms->lpstrReturn = NULL;
- lpParms->dwRetSize = 0;
- return 0;
-}
-
-
-/**************************************************************************
-* mciStatus [internal]
-*/
-DWORD mciStatus(UINT wDevID, DWORD dwParam, LPMCI_STATUS_PARMS lpParms)
-{
- if (lpParms == NULL) return MCIERR_INTERNAL;
- return 0;
-}
-
-
-/**************************************************************************
-* mciPlay [internal]
-*/
-DWORD mciPlay(UINT wDevID, DWORD dwParam, LPMCI_PLAY_PARMS lpParms)
-{
- if (lpParms == NULL) return MCIERR_INTERNAL;
- return 0;
-}
-
-
-/**************************************************************************
-* mciRecord [internal]
-*/
-DWORD mciRecord(UINT wDevID, DWORD dwParam, LPMCI_RECORD_PARMS lpParms)
-{
- if (lpParms == NULL) return MCIERR_INTERNAL;
- return 0;
-}
-
-
-/**************************************************************************
-* mciClose [internal]
-*/
-DWORD mciClose(UINT wDevID)
-{
- return 0;
-}
-
/**************************************************************************
* mciSendCommand [MMSYSTEM.701]
*/
DWORD mciSendCommand(UINT wDevID, UINT wMsg, DWORD dwParam1, DWORD dwParam2)
{
+ HDRVR hDrv = 0;
+#ifdef DEBUG_MCI
printf("mciSendCommand(%04X, %04X, %08X, %08X)\n",
wDevID, wMsg, dwParam1, dwParam2);
+#endif
switch(wMsg) {
case MCI_OPEN:
- printf("mciSendCommand // MCI_OPEN !\n");
- if (dwParam1 & MCI_WAVE_OPEN_BUFFER)
- return mciWaveOpen(wDevID, dwParam1,
- (LPMCI_WAVE_OPEN_PARMS)dwParam2);
- else
- return mciOpen(wDevID, dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
- case MCI_PLAY:
- printf("mciSendCommand // MCI_PLAY !\n");
- return mciPlay(wDevID, dwParam1, (LPMCI_PLAY_PARMS)dwParam2);
- case MCI_RECORD:
- printf("mciSendCommand // MCI_RECORD !\n");
- return mciRecord(wDevID, dwParam1, (LPMCI_RECORD_PARMS)dwParam2);
+ return mciOpen(dwParam1, (LPMCI_OPEN_PARMS)dwParam2);
case MCI_CLOSE:
- printf("mciSendCommand // MCI_CLOSE !\n");
- return mciClose(wDevID);
- case MCI_SOUND:
- printf("mciSendCommand // MCI_SOUND !\n");
- return mciSound(wDevID, dwParam1, (LPMCI_SOUND_PARMS)dwParam2);
- case MCI_STATUS:
- printf("mciSendCommand // MCI_STATUS !\n");
- return mciStatus(wDevID, dwParam1, (LPMCI_STATUS_PARMS)dwParam2);
- case MCI_INFO:
- printf("mciSendCommand // MCI_INFO !\n");
- return mciInfo(wDevID, dwParam1, (LPMCI_INFO_PARMS)dwParam2);
- case MCI_GETDEVCAPS:
- printf("mciSendCommand // MCI_GETDEVCAPS !\n");
- return mciGetDevCaps(wDevID, dwParam1, (LPMCI_GETDEVCAPS_PARMS)dwParam2);
+ return mciClose(wDevID, dwParam1, (LPMCI_GENERIC_PARMS)dwParam2);
+ default:
+ switch(mciDrv[wDevID].wType) {
+ case MCI_DEVTYPE_CD_AUDIO:
+ return CDAUDIO_DriverProc(mciDrv[wDevID].wDeviceID, hDrv,
+ wMsg, dwParam1, dwParam2);
+ case MCI_DEVTYPE_WAVEFORM_AUDIO:
+ return WAVE_DriverProc(mciDrv[wDevID].wDeviceID, hDrv,
+ wMsg, dwParam1, dwParam2);
+ default:
+ printf("mciSendCommand() // unknown type=%04X !\n",
+ mciDrv[wDevID].wType);
+ }
}
- return MCIERR_DEVICE_NOT_INSTALLED;
+ return MMSYSERR_INVALPARAM;
}
/**************************************************************************
@@ -670,7 +710,13 @@
*/
UINT mciGetDeviceID (LPCSTR lpstrName)
{
+ char str[128];
printf("mciGetDeviceID(%s)\n", lpstrName);
+ if (lpstrName != NULL) {
+ strcpy(str, lpstrName);
+ AnsiUpper(str);
+ if (strcmp(str, "ALL") == 0) return MCI_ALL_DEVICE_ID;
+ }
return 0;
}
@@ -1046,8 +1092,11 @@
*/
UINT WINAPI waveOutGetNumDevs()
{
+ UINT count = 0;
printf("waveOutGetNumDevs\n");
- return 1;
+ count += wodMessage(0, WODM_GETNUMDEVS, 0L, 0L, 0L);
+ printf("waveOutGetNumDevs return %u \n", count);
+ return count;
}
/**************************************************************************
@@ -1056,7 +1105,7 @@
UINT WINAPI waveOutGetDevCaps(UINT uDeviceID, WAVEOUTCAPS FAR* lpCaps, UINT uSize)
{
printf("waveOutGetDevCaps\n");
- return MMSYSERR_INVALHANDLE;
+ return wodMessage(uDeviceID, WODM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
}
/**************************************************************************
@@ -1144,20 +1193,42 @@
UINT WINAPI waveOutOpen(HWAVEOUT FAR* lphWaveOut, UINT uDeviceID,
const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
{
+ HWAVE hWaveOut;
+ LPWAVEOPENDESC lpDesc;
+ DWORD dwRet;
+ BOOL bMapperFlg = FALSE;
printf("waveOutOpen(%08X, %d, %08X, %08X, %08X, %08X);\n",
lphWaveOut, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
if (dwFlags & WAVE_FORMAT_QUERY) {
- printf("waveOutOpen // WAVE_FORMAT_QUERY !\n");
- if (uDeviceID == (UINT)WAVE_MAPPER) {
- printf("waveOutOpen // No WAVE_MAPPER supported yet !\n");
- return MMSYSERR_BADDEVICEID;
- }
+ printf("waveOutOpen // WAVE_FORMAT_QUERY requested !\n");
+ }
+ if (uDeviceID == (UINT)WAVE_MAPPER) {
+ printf("waveOutOpen // WAVE_MAPPER mode requested !\n");
+ bMapperFlg = TRUE;
+ uDeviceID = 0;
}
if (lpFormat == NULL) return WAVERR_BADFORMAT;
- if (lphWaveOut != NULL) *lphWaveOut = 0;
- if (lphWaveOut != NULL) *lphWaveOut = ++mciActiveDev;
- return 0;
-/* return MMSYSERR_BADDEVICEID;*/
+ hWaveOut = GlobalAlloc(GMEM_MOVEABLE, sizeof(WAVEOPENDESC));
+ if (lphWaveOut != NULL) *lphWaveOut = hWaveOut;
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveOut);
+ if (lpDesc == NULL) return MMSYSERR_NOMEM;
+ lpDesc->hWave = hWaveOut;
+ lpDesc->lpFormat = lpFormat;
+ lpDesc->dwCallBack = dwCallback;
+ lpDesc->dwInstance = dwInstance;
+ while(uDeviceID < MAXWAVEDRIVERS) {
+ dwRet = wodMessage(uDeviceID, WODM_OPEN,
+ lpDesc->dwInstance, (DWORD)lpDesc, 0L);
+ if (dwRet == MMSYSERR_NOERROR) break;
+ if (!bMapperFlg) break;
+ uDeviceID++;
+ printf("waveOutOpen // WAVE_MAPPER mode ! try next driver...\n");
+ }
+ if (dwFlags & WAVE_FORMAT_QUERY) {
+ printf("waveOutOpen // End of WAVE_FORMAT_QUERY !\n");
+ waveOutClose(hWaveOut);
+ }
+ return dwRet;
}
/**************************************************************************
@@ -1165,8 +1236,11 @@
*/
UINT WINAPI waveOutClose(HWAVEOUT hWaveOut)
{
- printf("waveOutClose\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveOutClose(%04X)\n", hWaveOut);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveOut);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return wodMessage(0, WODM_CLOSE, lpDesc->dwInstance, 0L, 0L);
}
/**************************************************************************
@@ -1175,8 +1249,13 @@
UINT WINAPI waveOutPrepareHeader(HWAVEOUT hWaveOut,
WAVEHDR FAR* lpWaveOutHdr, UINT uSize)
{
- printf("waveOutPrepareHeader\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveOutPrepareHeader(%04X, %08X, %u);\n",
+ hWaveOut, lpWaveOutHdr, uSize);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveOut);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return wodMessage(0, WODM_PREPARE, lpDesc->dwInstance,
+ (DWORD)lpWaveOutHdr, uSize);
}
/**************************************************************************
@@ -1185,8 +1264,13 @@
UINT WINAPI waveOutUnprepareHeader(HWAVEOUT hWaveOut,
WAVEHDR FAR* lpWaveOutHdr, UINT uSize)
{
- printf("waveOutUnprepareHeader\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveOutUnprepareHeader(%04X, %08X, %u);\n",
+ hWaveOut, lpWaveOutHdr, uSize);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveOut);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return wodMessage(0, WODM_PREPARE, lpDesc->dwInstance,
+ (DWORD)lpWaveOutHdr, uSize);
}
/**************************************************************************
@@ -1194,8 +1278,12 @@
*/
UINT WINAPI waveOutWrite(HWAVEOUT hWaveOut, WAVEHDR FAR* lpWaveOutHdr, UINT uSize)
{
- printf("waveOutWrite\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveOutWrite(%04X, %08X, %u);\n", hWaveOut, lpWaveOutHdr, uSize);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveOut);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return wodMessage(0, WODM_WRITE, lpDesc->dwInstance,
+ (DWORD)lpWaveOutHdr, uSize);
}
/**************************************************************************
@@ -1203,7 +1291,7 @@
*/
UINT WINAPI waveOutPause(HWAVEOUT hWaveOut)
{
- printf("waveOutPause\n");
+ printf("waveOutPause(%04X)\n", hWaveOut);
return MMSYSERR_INVALHANDLE;
}
@@ -1212,7 +1300,7 @@
*/
UINT WINAPI waveOutRestart(HWAVEOUT hWaveOut)
{
- printf("waveOutRestart\n");
+ printf("waveOutRestart(%04X)\n", hWaveOut);
return MMSYSERR_INVALHANDLE;
}
@@ -1221,17 +1309,21 @@
*/
UINT WINAPI waveOutReset(HWAVEOUT hWaveOut)
{
- printf("waveOutReset\n");
+ printf("waveOutReset(%04X)\n", hWaveOut);
return MMSYSERR_INVALHANDLE;
}
/**************************************************************************
* waveOutGetPosition [MMSYSTEM.412]
*/
-UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, MMTIME FAR* lpInfo, UINT uSize)
+UINT WINAPI waveOutGetPosition(HWAVEOUT hWaveOut, MMTIME FAR* lpTime, UINT uSize)
{
- printf("waveOutGetPosition\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveOutGetPosition(%04X, %08X, %u);\n", hWaveOut, lpTime, uSize);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveOut);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return wodMessage(0, WODM_GETPOS, lpDesc->dwInstance,
+ (DWORD)lpTime, (DWORD)uSize);
}
/**************************************************************************
@@ -1293,7 +1385,7 @@
*/
UINT WINAPI waveOutBreakLoop(HWAVEOUT hWaveOut)
{
- printf("waveOutBreakLoop\n");
+ printf("waveOutBreakLoop(%04X)\n", hWaveOut);
return MMSYSERR_INVALHANDLE;
}
@@ -1319,8 +1411,11 @@
*/
UINT WINAPI waveInGetNumDevs()
{
+ UINT count = 0;
printf("waveInGetNumDevs\n");
- return 0;
+ count += widMessage(0, WIDM_GETNUMDEVS, 0L, 0L, 0L);
+ printf("waveInGetNumDevs return %u \n", count);
+ return count;
}
@@ -1330,7 +1425,7 @@
UINT WINAPI waveInGetDevCaps(UINT uDeviceID, WAVEINCAPS FAR* lpCaps, UINT uSize)
{
printf("waveInGetDevCaps\n");
- return MMSYSERR_INVALHANDLE;
+ return widMessage(uDeviceID, WIDM_GETDEVCAPS, 0L, (DWORD)lpCaps, uSize);
}
@@ -1350,18 +1445,42 @@
UINT WINAPI waveInOpen(HWAVEIN FAR* lphWaveIn, UINT uDeviceID,
const LPWAVEFORMAT lpFormat, DWORD dwCallback, DWORD dwInstance, DWORD dwFlags)
{
+ HWAVE hWaveIn;
+ LPWAVEOPENDESC lpDesc;
+ DWORD dwRet;
+ BOOL bMapperFlg = FALSE;
printf("waveInOpen(%08X, %d, %08X, %08X, %08X, %08X);\n",
lphWaveIn, uDeviceID, lpFormat, dwCallback, dwInstance, dwFlags);
if (dwFlags & WAVE_FORMAT_QUERY) {
- printf("waveInOpen // WAVE_FORMAT_QUERY !\n");
- if (uDeviceID == (UINT)WAVE_MAPPER) {
- printf("waveInOpen // No WAVE_MAPPER supported yet !\n");
- return MMSYSERR_BADDEVICEID;
- }
+ printf("waveInOpen // WAVE_FORMAT_QUERY requested !\n");
}
- if (lphWaveIn != NULL) *lphWaveIn = 0;
+ if (uDeviceID == (UINT)WAVE_MAPPER) {
+ printf("waveInOpen // WAVE_MAPPER mode requested !\n");
+ bMapperFlg = TRUE;
+ uDeviceID = 0;
+ }
if (lpFormat == NULL) return WAVERR_BADFORMAT;
- return MMSYSERR_BADDEVICEID;
+ hWaveIn = GlobalAlloc(GMEM_MOVEABLE, sizeof(WAVEOPENDESC));
+ if (lphWaveIn != NULL) *lphWaveIn = hWaveIn;
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_NOMEM;
+ lpDesc->hWave = hWaveIn;
+ lpDesc->lpFormat = lpFormat;
+ lpDesc->dwCallBack = dwCallback;
+ lpDesc->dwInstance = dwInstance;
+ while(uDeviceID < MAXWAVEDRIVERS) {
+ dwRet = widMessage(uDeviceID, WIDM_OPEN,
+ lpDesc->dwInstance, (DWORD)lpDesc, 0L);
+ if (dwRet == MMSYSERR_NOERROR) break;
+ if (!bMapperFlg) break;
+ uDeviceID++;
+ printf("waveInOpen // WAVE_MAPPER mode ! try next driver...\n");
+ }
+ if (dwFlags & WAVE_FORMAT_QUERY) {
+ printf("waveInOpen // End of WAVE_FORMAT_QUERY !\n");
+ waveInClose(hWaveIn);
+ }
+ return dwRet;
}
@@ -1370,8 +1489,11 @@
*/
UINT WINAPI waveInClose(HWAVEIN hWaveIn)
{
- printf("waveInClose\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveInClose(%04X)\n", hWaveIn);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return widMessage(0, WIDM_CLOSE, lpDesc->dwInstance, 0L, 0L);
}
@@ -1381,8 +1503,18 @@
UINT WINAPI waveInPrepareHeader(HWAVEIN hWaveIn,
WAVEHDR FAR* lpWaveInHdr, UINT uSize)
{
- printf("waveInPrepareHeader\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveInPrepareHeader(%04X, %08X, %u);\n",
+ hWaveIn, lpWaveInHdr, uSize);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
+ lpWaveInHdr->lpNext = NULL;
+ lpWaveInHdr->dwBytesRecorded = 0;
+ printf("waveInPrepareHeader // lpData=%08X size=%u \n",
+ lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
+ return widMessage(0, WIDM_PREPARE, lpDesc->dwInstance,
+ (DWORD)lpWaveInHdr, uSize);
}
@@ -1392,20 +1524,36 @@
UINT WINAPI waveInUnprepareHeader(HWAVEIN hWaveIn,
WAVEHDR FAR* lpWaveInHdr, UINT uSize)
{
- printf("waveInUnprepareHeader\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveInUnprepareHeader(%04X, %08X, %u);\n",
+ hWaveIn, lpWaveInHdr, uSize);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ USER_HEAP_FREE(HIWORD((DWORD)lpWaveInHdr->lpData));
+ lpWaveInHdr->lpData = NULL;
+ lpWaveInHdr->lpNext = NULL;
+ return widMessage(0, WIDM_PREPARE, lpDesc->dwInstance,
+ (DWORD)lpWaveInHdr, uSize);
}
-
/**************************************************************************
* waveInAddBuffer [MMSYSTEM.508]
*/
UINT WINAPI waveInAddBuffer(HWAVEIN hWaveIn,
WAVEHDR FAR* lpWaveInHdr, UINT uSize)
{
- printf("waveInAddBuffer\n");
- return 0;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveInAddBuffer(%04X, %08X, %u);\n", hWaveIn, lpWaveInHdr, uSize);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ if (lpWaveInHdr == NULL) return MMSYSERR_INVALHANDLE;
+ lpWaveInHdr->lpNext = NULL;
+ lpWaveInHdr->dwBytesRecorded = 0;
+ printf("waveInAddBuffer // lpData=%08X size=%u \n",
+ lpWaveInHdr->lpData, lpWaveInHdr->dwBufferLength);
+ return widMessage(0, WIDM_ADDBUFFER, lpDesc->dwInstance,
+ (DWORD)lpWaveInHdr, uSize);
}
@@ -1414,8 +1562,11 @@
*/
UINT WINAPI waveInStart(HWAVEIN hWaveIn)
{
- printf("waveInStart\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveInStart(%04X)\n", hWaveIn);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return widMessage(0, WIDM_START, lpDesc->dwInstance, 0L, 0L);
}
@@ -1424,8 +1575,11 @@
*/
UINT WINAPI waveInStop(HWAVEIN hWaveIn)
{
- printf("waveInStop\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveInStop(%04X)\n", hWaveIn);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return widMessage(0, WIDM_STOP, lpDesc->dwInstance, 0L, 0L);
}
@@ -1434,18 +1588,25 @@
*/
UINT WINAPI waveInReset(HWAVEIN hWaveIn)
{
- printf("waveInReset\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveInReset(%04X)\n", hWaveIn);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return widMessage(0, WIDM_RESET, lpDesc->dwInstance, 0L, 0L);
}
/**************************************************************************
* waveInGetPosition [MMSYSTEM.512]
*/
-UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, MMTIME FAR* lpInfo, UINT uSize)
+UINT WINAPI waveInGetPosition(HWAVEIN hWaveIn, MMTIME FAR* lpTime, UINT uSize)
{
- printf("waveInGetPosition\n");
- return MMSYSERR_INVALHANDLE;
+ LPWAVEOPENDESC lpDesc;
+ printf("waveInGetPosition(%04X, %08X, %u);\n", hWaveIn, lpTime, uSize);
+ lpDesc = (LPWAVEOPENDESC) GlobalLock(hWaveIn);
+ if (lpDesc == NULL) return MMSYSERR_INVALHANDLE;
+ return widMessage(0, WIDM_GETPOS, lpDesc->dwInstance,
+ (DWORD)lpTime, (DWORD)uSize);
}
@@ -1455,6 +1616,7 @@
UINT WINAPI waveInGetID(HWAVEIN hWaveIn, UINT FAR* lpuDeviceID)
{
printf("waveInGetID\n");
+ if (lpuDeviceID == NULL) return MMSYSERR_INVALPARAM;
return 0;
}
@@ -1540,7 +1702,7 @@
printf("timeSetEvent(%u, %u, %08X, %08X, %04X);\n",
wDelay, wResol, lpFunc, dwUser, wFlags);
if (!mmTimeStarted) StartMMTime();
- lpNewTimer = malloc(sizeof(TIMERENTRY));
+ lpNewTimer = (LPTIMERENTRY) malloc(sizeof(TIMERENTRY));
if (lpNewTimer == NULL) return 0;
while (lpTimer != NULL) {
wNewID = max(wNewID, lpTimer->wTimerID);
@@ -1628,8 +1790,10 @@
*/
HMMIO WINAPI mmioOpen(LPSTR szFileName, MMIOINFO FAR* lpmmioinfo, DWORD dwOpenFlags)
{
+ int hFile;
printf("mmioOpen('%s', %08X, %08X);\n", szFileName, lpmmioinfo, dwOpenFlags);
- return 0;
+ hFile = _lopen(szFileName, dwOpenFlags);
+ return (HMMIO)hFile;
}
@@ -1640,6 +1804,7 @@
UINT WINAPI mmioClose(HMMIO hmmio, UINT uFlags)
{
printf("mmioClose(%04X, %04X);\n", hmmio, uFlags);
+ _lclose(hmmio);
return 0;
}
@@ -1651,6 +1816,7 @@
LONG WINAPI mmioRead(HMMIO hmmio, HPSTR pch, LONG cch)
{
printf("mmioRead\n");
+ _lread(hmmio, pch, cch);
return 0;
}
@@ -1815,8 +1981,10 @@
*/
LRESULT WINAPI DrvSendMessage(HDRVR hDriver, WORD msg, LPARAM lParam1, LPARAM lParam2)
{
+ DWORD dwDevID = 0;
printf("DrvSendMessage(%04X, %04X, %08X, %08X);\n",
hDriver, msg, lParam1, lParam2);
+ return CDAUDIO_DriverProc(dwDevID, hDriver, msg, lParam1, lParam2);
}
/**************************************************************************
diff --git a/miscemu/int2f.c b/miscemu/int2f.c
index 0a7d14e..046337c 100644
--- a/miscemu/int2f.c
+++ b/miscemu/int2f.c
@@ -3,6 +3,9 @@
#include "msdos.h"
#include "wine.h"
+int do_int2f_16(struct sigcontext_struct *context);
+
+
int do_int2f(struct sigcontext_struct *context)
{
switch((context->sc_eax >> 8) & 0xff)
@@ -12,17 +15,41 @@
return 1;
case 0x16:
- switch(context->sc_eax & 0xff)
- {
- case 0x00: /* windows enhanced mode install check */
- /* don't return anything as we're running in standard mode */
- return 1;
-
- default:
- }
+ return do_int2f_16(context);
default:
IntBarf(0x2f, context);
};
return 1;
}
+
+
+int do_int2f_16(struct sigcontext_struct *context)
+{
+ switch(context->sc_eax & 0xff) {
+ case 0x00:
+ /* return 'major/minor' for MSWin 3.1 */
+ printf("do_int2f_16 // return 'major/minor' for MSWin 3.1 !\n");
+ context->sc_eax = 0x0310;
+ return 1;
+ case 0x86:
+ /* operating in protected mode under DPMI */
+ printf("do_int2f_16 // operating in protected mode under DPMI !\n");
+ context->sc_eax = 0x0000;
+ return 1;
+ case 0x87:
+ printf("do_int2f_16 // return DPMI flags !\n");
+ context->sc_eax = 0x0000; /* DPMI Installed */
+ context->sc_ebx = 0x0001; /* 32bits available */
+ context->sc_ecx = 0x04; /* processor 486 */
+ context->sc_edx = 0x0100; /* DPMI major/minor */
+ context->sc_esi = 0; /* # of para. of DOS */
+ /* extended private data */
+ return 1;
+ default:
+ IntBarf(0x2f, context);
+ }
+ return 1;
+}
+
+
diff --git a/windows/class.c b/windows/class.c
index 753ee0d..622afe1 100644
--- a/windows/class.c
+++ b/windows/class.c
@@ -91,7 +91,8 @@
{
CLASS * newClass, * prevClassPtr;
HCLASS handle, prevClass;
-
+ int classExtra;
+
#ifdef DEBUG_CLASS
printf( "RegisterClass: wndproc=%08x hinst=%d name='%s' background %x\n",
class->lpfnWndProc, class->hInstance, class->lpszClassName,
@@ -110,20 +111,18 @@
if (!(prevClassPtr->wc.style & CS_GLOBALCLASS)) return 0;
}
- /* bug for bug compatible */
-
- if (class->cbClsExtra < 0) class->cbClsExtra = 0;
- if (class->cbWndExtra < 0) class->cbWndExtra = 0;
-
/* Create class */
- handle = USER_HEAP_ALLOC( GMEM_MOVEABLE, sizeof(CLASS)+class->cbClsExtra );
+ classExtra = (class->cbClsExtra < 0) ? 0 : class->cbClsExtra;
+ handle = USER_HEAP_ALLOC( GMEM_MOVEABLE, sizeof(CLASS) + classExtra );
if (!handle) return 0;
newClass = (CLASS *) USER_HEAP_ADDR( handle );
- newClass->hNext = firstClass;
- newClass->wMagic = CLASS_MAGIC;
- newClass->cWindows = 0;
- newClass->wc = *class;
+ newClass->hNext = firstClass;
+ newClass->wMagic = CLASS_MAGIC;
+ newClass->cWindows = 0;
+ newClass->wc = *class;
+ newClass->wc.cbWndExtra = (class->cbWndExtra < 0) ? 0 : class->cbWndExtra;
+ newClass->wc.cbClsExtra = classExtra;
if (newClass->wc.style & CS_GLOBALCLASS)
newClass->atomName = GlobalAddAtom( class->lpszClassName );
@@ -147,7 +146,7 @@
}
}
- if (class->cbClsExtra) memset( newClass->wExtra, 0, class->cbClsExtra );
+ if (classExtra) memset( newClass->wExtra, 0, classExtra );
firstClass = handle;
return newClass->atomName;
}
diff --git a/windows/dc.c b/windows/dc.c
index 947372d..056329a 100644
--- a/windows/dc.c
+++ b/windows/dc.c
@@ -105,7 +105,6 @@
SelectObject( hdc, dc->w.hFont );
XSetGraphicsExposures( XT_display, dc->u.x.gc, False );
CLIPPING_SetDeviceClipping( dc );
- FONT_SelectObject(dc, STOCK_SYSTEM_FIXED_FONT, NULL);
}
@@ -204,7 +203,7 @@
if (!dc->u.x.font.fstruct)
{
- FONT_SelectObject(dc, STOCK_SYSTEM_FIXED_FONT, NULL);
+ FONT_SelectObject(dc, STOCK_SYSTEM_FONT, NULL);
}
val.function = DC_XROPfunction[dc->w.ROPmode-1];
val.foreground = dc->w.textPixel;
@@ -235,6 +234,7 @@
#endif
memcpy( &newdc->w, &dc->w, sizeof(dc->w) );
+ memcpy( &newdc->u.x.pen, &dc->u.x.pen, sizeof(dc->u.x.pen) );
newdc->saveLevel = 0;
newdc->w.flags |= DC_SAVED;
diff --git a/windows/dialog.c b/windows/dialog.c
index 7edc656..47ad5b4 100644
--- a/windows/dialog.c
+++ b/windows/dialog.c
@@ -595,13 +595,13 @@
*/
void CheckRadioButton( HWND hwndDlg, WORD firstID, WORD lastID, WORD checkID )
{
- HWND button = GetDlgItem( hwndDlg, firstID );
+ HWND button = GetDlgItem( hwndDlg, lastID );
while (button != 0)
{
WND * wndPtr = WIN_FindWndPtr( button );
if (!wndPtr) break;
SendMessage( button, BM_SETCHECK, (wndPtr->wIDmenu == checkID), 0 );
- if (wndPtr->wIDmenu == lastID) break;
+ if (wndPtr->wIDmenu == firstID) break;
button = wndPtr->hwndNext;
}
}
diff --git a/windows/graphics.c b/windows/graphics.c
index 0d2392f..c21eff3 100644
--- a/windows/graphics.c
+++ b/windows/graphics.c
@@ -153,6 +153,8 @@
(double)(xend-xcenter)*(bottom-top) );
diff_angle = end_angle - start_angle;
if (diff_angle < 0.0) diff_angle += 2*PI;
+ if (left > right) swap_int( &left, &right );
+ if (top > bottom) swap_int( &top, &bottom );
XDrawArc( display, dc->u.x.drawable, dc->u.x.gc,
dc->w.DCOrgX + left, dc->w.DCOrgY + top,
diff --git a/windows/painting.c b/windows/painting.c
index 65a17ca..abac9b5 100644
--- a/windows/painting.c
+++ b/windows/painting.c
@@ -45,13 +45,6 @@
if (!(wndPtr->flags & WIN_ERASE_UPDATERGN)) lps->fErase = TRUE;
else lps->fErase = !SendMessage( hwnd, WM_ERASEBKGND, lps->hdc, 0 );
- /*
- * a BeginPaint should return with these objects set by default
- */
- SelectObject(lps->hdc, STOCK_BLACK_PEN);
- SelectObject(lps->hdc, STOCK_WHITE_BRUSH);
- SelectObject(lps->hdc, STOCK_SYSTEM_FONT);
-
return lps->hdc;
}
diff --git a/windows/win.c b/windows/win.c
index cc11dd1..d768512 100644
--- a/windows/win.c
+++ b/windows/win.c
@@ -253,7 +253,10 @@
exStyle, className, windowName, style, x, y, width, height,
parent, menu, instance, data);
#endif
-
+ /* 'soundrec.exe' has negative position !
+ Why ? For now, here a patch : */
+ if (x < 0) x = 0;
+ if (y < 0) y = 0;
if (x == CW_USEDEFAULT) x = y = 0;
if (width == CW_USEDEFAULT)
{
@@ -366,24 +369,15 @@
else
win_attr.backing_store = Always;
- if (Options.nosaveunders)
- win_attr.save_under = FALSE;
- else
- win_attr.save_under = TRUE;
+ win_attr.save_under = ((classPtr->wc.style & CS_SAVEBITS) != 0);
-
- /* set the background of all windows to be white, just like
- * MS-Windows does (hopefully!)
- */
- win_attr.background_pixel = WhitePixelOfScreen(screen);
-
wndPtr->window = XCreateWindow( display, parentPtr->window,
x + parentPtr->rectClient.left - parentPtr->rectWindow.left,
y + parentPtr->rectClient.top - parentPtr->rectWindow.top,
width, height, 0,
CopyFromParent, InputOutput, CopyFromParent,
CWEventMask | CWOverrideRedirect | CWColormap |
- CWSaveUnder | CWBackingStore | CWBackPixel, &win_attr );
+ CWSaveUnder | CWBackingStore, &win_attr );
XStoreName( display, wndPtr->window, windowName );
