able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/media/test/mmiotest/mmiotest.c

1119 lines
34 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/* MMIOTest.c
*
* Test the MMIO library.
*/
#include "mmiot32.h" // (Win32)
/* constants */
#define MMIOM_ANSWER (MMIOM_USER + 1) // get answer to the universe
/* globals */
char gszAppName[] = "MMIOTest"; // for title bar etc.
HANDLE ghInst; // program instance handle
/* prototypes */
void PASCAL AppPaint(HWND hwnd, HDC hdc);
BOOL FAR PASCAL AppAbout(HWND hDlg, UINT uMessage,
DWORD dwParam, LONG lParam);
BOOL PASCAL AppInit(HANDLE hInst, HANDLE hPrev);
LONG FAR PASCAL AppWndProc(HWND hwnd, UINT uMessage,
DWORD dwParam, LONG lParam);
int WINAPI WinMain(HANDLE hInst, HANDLE hPrev, LPSTR lpszCmdLine, int iCmdShow);
void NEAR PASCAL Test1(HWND hwnd);
void NEAR PASCAL TestHelloWorld(HMMIO hmmio, LONG lBufSize);
MMIOPROC RCDIOProc;
void NEAR PASCAL Test2(HWND hwnd);
void NEAR PASCAL Test2Helper(BOOL fMemFile);
void NEAR PASCAL FillBufferedFile(HMMIO hmmio, LONG lLongs);
void NEAR PASCAL Test3(HWND hwnd);
void NEAR PASCAL TestRIFF(HMMIO hmmio, BOOL fReadable);
LPSTR NEAR PASCAL lstrrchr(LPSTR szSrc, char ch);
#ifdef OMIT
void NEAR PASCAL lmemset(void far *pDst, BYTE bSrc, long cDst);
#endif //OMIT
/* AppPaint(hwnd, hdc)
*
* This function is called whenever the application windows needs to be
* redrawn.
*/
void PASCAL
AppPaint(
HWND hwnd, // window painting into
HDC hdc) // display context to paint to
{
}
/* AppAbout(hDlg, uMessage, dwParam, lParam)
*
* This function handles messages belonging to the "About" dialog box.
* The only message that it looks for is WM_COMMAND, indicating the use
* has pressed the "OK" button. When this happens, it takes down
* the dialog box.
*/
BOOL FAR PASCAL // TRUE iff message has been processed
AppAbout(
HWND hDlg, // window handle of "about" dialog box
UINT uMessage, // message number
DWORD dwParam, // message-dependent parameter
LONG lParam) // message-dependent parameter
{
switch (uMessage)
{
case WM_COMMAND:
if (dwParam == IDOK)
EndDialog(hDlg, TRUE);
break;
case WM_INITDIALOG:
return TRUE;
}
return FALSE;
}
/* AppInit(hInst, hPrev)
*
* This is called when the application is first loaded into memory.
* It performs all initialization that doesn't need to be done once
* per instance.
*/
BOOL PASCAL // returns TRUE iff successful
AppInit(
HANDLE hInst, // instance handle of current instance
HANDLE hPrev) // instance handle of previous instance
{
WNDCLASS wndclass;
#if DBG
#if BOGUS //Laurie
wpfGetDebugLevel(gszAppName);
#endif
#endif
if (!hPrev)
{
/* Register a class for the main application window */
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.hIcon = LoadIcon(hInst, "AppIcon");
wndclass.lpszMenuName = "AppMenu";
wndclass.lpszClassName = gszAppName;
/* wndclass.hbrBackground = (HBRUSH) COLOR_WINDOW + 1; */
wndclass.hbrBackground = GetStockObject(BLACK_BRUSH);
wndclass.hInstance = hInst; // (Win32)
wndclass.style = CS_BYTEALIGNCLIENT | CS_VREDRAW | CS_HREDRAW;
wndclass.lpfnWndProc = (WNDPROC)AppWndProc;
wndclass.cbWndExtra = 0;
wndclass.cbClsExtra = 0;
if (!RegisterClass(&wndclass))
return FALSE;
}
return TRUE;
}
/* WinMain(hInst, hPrev, lpszCmdLine, cmdShow)
*
* The main procedure for the App. After initializing, it just goes
* into a message-processing loop until it gets a WM_QUIT message
* (meaning the app was closed).
*/
int WINAPI // returns exit code specified in WM_QUIT
WinMain(
HANDLE hInst, // instance handle of current instance
HANDLE hPrev, // instance handle of previous instance
LPSTR lpszCmdLine, // null-terminated command line
int iCmdShow) // how window should be initially displayed
{
MSG msg; // message from queue
HWND hwnd; // handle to app's window
/* save instance handle for dialog boxes */
ghInst = hInst;
/* call initialization procedure */
if (!AppInit(hInst, hPrev))
return FALSE;
/* create the application's window */
hwnd = CreateWindow
(
gszAppName, // window class
gszAppName, // window caption
WS_OVERLAPPEDWINDOW, // window style
CW_USEDEFAULT, 0, // initial position
CW_USEDEFAULT, 0, // initial size
NULL, // parent window handle
NULL, // window menu handle
hInst, // program instance handle
NULL // create parameters
);
ShowWindow(hwnd, iCmdShow);
/* get messages from event queue and dispatch them */
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return msg.wParam; /* Note: wParam is a DWORD in NT */
}
/* AppWndProc(hwnd, uMessage, dwParam, lParam)
*
* The window proc for the app's main window. This processes all
* of the parent window's messages.
*/
LONG FAR PASCAL // returns 0 iff processed message
AppWndProc(
HWND hwnd, // window's handle
UINT uMessage, // message number
DWORD dwParam, // message-dependent parameter
LONG lParam) // message-dependent parameter
{
#ifdef WIN16
FARPROC fpfn;
#endif
PAINTSTRUCT ps;
BOOL fAllTests = FALSE;
switch (uMessage)
{
case WM_COMMAND:
switch (dwParam)
{
case IDM_ABOUT:
/* request to display "About" dialog box */
#ifdef WIN16
fpfn = MakeProcInstance((FARPROC) AppAbout, ghInst);
DialogBox(ghInst, MAKEINTRESOURCE(ABOUTBOX),
hwnd, fpfn);
FreeProcInstance(fpfn);
#else
DialogBox(ghInst, MAKEINTRESOURCE(ABOUTBOX),
hwnd, (DLGPROC)AppAbout);
#endif
break;
case IDM_EXIT:
/* request to exit this program */
PostMessage(hwnd, WM_SYSCOMMAND, SC_CLOSE, 0L);
break;
case IDM_ALLTESTS:
fAllTests = TRUE;
/* fall through */
case IDM_TEST1:
dprintf("\n--------------- Test1 ---------------\n");
Test1(hwnd);
dprintf("Done Test1.\n");
if (!fAllTests)
break;
case IDM_TEST2:
dprintf("\n--------------- Test2 ---------------\n");
Test2(hwnd);
dprintf("Done Test2.\n");
if (!fAllTests)
break;
case IDM_TEST3:
dprintf("\n--------------- Test3 ---------------\n");
Test3(hwnd);
dprintf("Done Test3.\n");
if (!fAllTests)
break;
dprintf("Done All Tests.\n");
break;
}
return 0L;
case WM_DESTROY:
/* exit this program */
PostQuitMessage(0);
break;
case WM_PAINT:
/* set up a paint structure, and call AppPaint() */
BeginPaint(hwnd, &ps);
AppPaint(hwnd, ps.hdc);
EndPaint(hwnd, &ps);
return 0;
}
return (LONG)DefWindowProc(hwnd, uMessage, dwParam, lParam);
}
void NEAR PASCAL
Test1(HWND hwnd)
{
HMMIO hmmio;
char achMemFile[100];
MMIOINFO mmioinfo;
HMMIO hmmioMF; // memory file handle
long lBufSize;
int fh;
FARPROC farproc; // Added to make it compile. LKG
dprintf("HelloWorld tests...\n");
/* open "hello.txt" unbuffered -- assume it contains
* "hello world\r\n" (13 bytes) -- and run the TestHelloWorld test
*/
WinEval((hmmio = mmioOpen("hello.txt", NULL, 0)) != NULL);
dprintf("TestHelloWorld() with no buffer\n");
TestHelloWorld(hmmio, 0);
for (lBufSize = 1; lBufSize <= 15; lBufSize++)
{
/* re-run test for various buffer sizes */
WinEval(mmioSetBuffer(hmmio, NULL, lBufSize, 0) == 0);
WinEval(mmioSeek(hmmio, 0L, SEEK_SET) == 0L);
dprintf("TestHelloWorld() with %ld-byte buffer\n",
lBufSize);
TestHelloWorld(hmmio, lBufSize);
}
/* copy file into a memory block, set up memory block
* as a memory file, and re-run the test
*/
WinEval(mmioSeek(hmmio, 0L, SEEK_SET) == 0L);
WinEval(mmioRead(hmmio, achMemFile, 13L) == 13L);
memset(&mmioinfo, 0, sizeof(mmioinfo));
mmioinfo.fccIOProc = FOURCC_MEM;
mmioinfo.pchBuffer = achMemFile;
mmioinfo.cchBuffer = 13L;
WinEval((hmmioMF = mmioOpen(NULL, &mmioinfo, 0)) != NULL);
dprintf("TestHelloWorld() with memory file\n");
TestHelloWorld(hmmioMF, 13L);
/* close the open files */
WinEval(mmioClose(hmmio, 0) == 0);
WinEval(mmioClose(hmmioMF, 0) == 0);
/* open file and pass file handle to mmioOpen() */
WinEval((fh = _lopen("hello.txt", READ)) >= 0);
memset(&mmioinfo, 0, sizeof(mmioinfo));
mmioinfo.adwInfo[0] = fh;
WinEval((hmmio = mmioOpen((LPSTR) NULL, &mmioinfo, MMIO_ALLOCBUF))
!= NULL);
dprintf("TestHelloWorld() with file handle passed to mmioOpen()\n");
TestHelloWorld(hmmio, 0);
WinEval(mmioClose(hmmio, 0) == 0);
/* "hello.txt" is stored as an RCDATA resource named "Hello" --
* use this to try out the custom I/O procedure stuff
*/
dprintf("register Win3 RCDATA custom I/O procedure\n");
#define FOURCC_RCD mmioFOURCC('R', 'C', 'D', ' ')
WinEval( (farproc = (FARPROC) RCDIOProc) != NULL );
/* installing it twice should just mean it has to be removed twice */
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_FINDPROC) == NULL);
WinEval(mmioInstallIOProc(FOURCC_RCD, (LPMMIOPROC) farproc,
MMIO_INSTALLPROC) == (LPMMIOPROC) farproc);
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_FINDPROC) == (LPMMIOPROC) farproc);
WinEval(mmioInstallIOProc(FOURCC_RCD, (LPMMIOPROC) farproc,
MMIO_INSTALLPROC) == (LPMMIOPROC) farproc);
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_FINDPROC) == (LPMMIOPROC) farproc);
/* run the test without an I/O buffer */
dprintf("TestHelloWorld() unbuffered, with custom I/O procedure\n");
WinEval((hmmio = mmioOpen("mmiotest.rcd+Hello", NULL, 0)) != NULL); // changed ! to + LKG
TestHelloWorld(hmmio, 0);
WinEval(mmioClose(hmmio, 0) == 0);
/* run the test with a standard-size I/O buffer */
dprintf("TestHelloWorld() buffered, with custom I/O procedure\n");
WinEval((hmmio = mmioOpen("mmiotest.rcd+Hello", NULL, MMIO_ALLOCBUF))
!= NULL);
TestHelloWorld(hmmio, MMIO_DEFAULTBUFFER);
WinEval(mmioClose(hmmio, 0) == 0);
/* remove the custom I/O procedure (it was installed twice above) */
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_FINDPROC) == (LPMMIOPROC) farproc);
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_REMOVEPROC) == (LPMMIOPROC) farproc);
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_FINDPROC) == (LPMMIOPROC) farproc);
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_REMOVEPROC) == (LPMMIOPROC) farproc);
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_FINDPROC) == NULL);
WinEval(mmioInstallIOProc(FOURCC_RCD, NULL,
MMIO_REMOVEPROC) == NULL);
/* make sure the I/O procedure got removed */
WinEval(mmioOpen("mmiotest.rcd+Hello", NULL, 0) == NULL);
}
void NEAR PASCAL
TestHelloWorld(HMMIO hmmio, LONG lBufSize)
{
MMIOINFO mmioinfo;
char ach[100];
long lOffset;
static NPSTR szHello = "hello world\r\n"; // contents of file
long lAnswer;
strcpy(ach, "Recognisable garbage!");
/* send the I/O procedure a custom message */
lAnswer = mmioSendMessage(hmmio, MMIOM_ANSWER, 20L, 22L);
dprintf("answer %ld, ", lAnswer);
/* expect to be at offset 0 now */
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 0L);
if (lBufSize > 0)
{
/* access buffer directly starting at "hello" */
WinEval(mmioGetInfo(hmmio, &mmioinfo, 0) == 0);
WinEval(mmioAdvance(hmmio, &mmioinfo, MMIO_READ) == 0);
WinEval(lstrncmp(mmioinfo.pchNext, szHello,
min((int) lBufSize, 13)) == 0);
if (lBufSize >= 2)
{
WinAssert((mmioinfo.pchEndWrite - mmioinfo.pchNext)
>= 2);
mmioinfo.pchNext += 2;
}
WinEval(mmioSetInfo(hmmio, &mmioinfo, 0) == 0);
/* expect to be at offset 2 now */
if (lBufSize >= 2)
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 2L);
/* access buffer directly starting at "world" */
WinEval(mmioSeek(hmmio, 6L, SEEK_SET) == 6L);
WinEval(mmioGetInfo(hmmio, &mmioinfo, 0) == 0);
WinEval(mmioAdvance(hmmio, &mmioinfo, MMIO_READ) == 0);
WinEval(lstrncmp(mmioinfo.pchNext, szHello + 6,
min((int) lBufSize, 13 - 6)) == 0);
WinEval(mmioSetInfo(hmmio, &mmioinfo, 0) == 0);
/* expect to still be at offset 6 */
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 6L);
}
/* go to offset 2 */
WinEval(mmioSeek(hmmio, 2L, SEEK_SET) == 2L);
/* read "llo" */
strcpy(ach, "Recognisable garbage!");
WinEval(mmioRead(hmmio, ach, 3) == 3);
WinEval(lstrncmp(ach, "llo", 3) == 0);
/* read " wor" */
WinEval(mmioRead(hmmio, ach, 4) == 4);
if (lstrncmp(ach, " wor", 4) != 0)
{ printf("ach = <%s>, expected < wor>", ach);
}
WinEval(lstrncmp(ach, " wor", 4) == 0);
/* expect to be at offset 9 now */
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 9L);
/* read "ld\r\n" -- ask for 7 bytes, but only expect 4 */
WinEval(mmioRead(hmmio, ach, 7) == 4);
WinEval(lstrncmp(ach, "ld\r\n", 4) == 0);
/* expect to be at end of file now */
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 13L);
/* test seeking and reading for each offset in the file */
dprintf("reading from offset");
for (lOffset = 0; lOffset <= 11; lOffset++)
{
dprintf(" %ld", lOffset);
WinEval(mmioSeek(hmmio, lOffset, SEEK_SET) == lOffset);
WinEval(mmioRead(hmmio, ach, 2) == 2);
WinEval(lstrncmp(ach, "hello world\r\n" + lOffset, 2) == 0);
}
dprintf(".\n");
/* check more seeking */
OutputDebugString("SEEK_SET\n");
WinEval(mmioSeek(hmmio, 0L, SEEK_SET) == 0L);
WinEval(mmioSeek(hmmio, 13L, SEEK_SET) == 13L);
OutputDebugString("SEEK_CUR\n");
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 13L);
WinEval(mmioSeek(hmmio, -2L, SEEK_CUR) == 11L);
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 11L);
WinEval(mmioSeek(hmmio, -11L, SEEK_CUR) == 0L);
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 0L);
OutputDebugString("SEEK_END\n");
WinEval(mmioSeek(hmmio, 11L, SEEK_END) == 2L);
OutputDebugString("SEEK_CUR\n");
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 2L);
/* measure the length of the file */
OutputDebugString("SEEK_END\n");
WinEval(mmioSeek(hmmio, 0L, SEEK_END) == 13L);
} /* TestHelloWorld */
/* 'RCD' I/O Procedure
*
* I/O procedure that will open e.g. "foo.rcd+bar" but it's a con.
* It will chech that what's between the . and + is rcd, it will
* check that bar is in fact "hello" and that foo is "mmiotest"
* It then has a spoof "file" containing "hello world\r\n"
*/
typedef struct _MMIORCDINFO // How RCD IOProc uses MMIO.adwInfo[]
{
int fh; // DOS file handle
long lOffset; // offset of start of resource
long lSize; // size of resource (bytes)
} MMIORCDINFO;
LONG FAR PASCAL
RCDIOProc(
LPSTR lpmmioStr, // I/O status block (cast to LPSTR)
UINT uMsg, // message number
LONG lParam1,
LONG lParam2) // message-specific parameters
{
LPMMIOINFO pmmio = (LPMMIOINFO) lpmmioStr;
MMIORCDINFO FAR *pInfo = (MMIORCDINFO FAR *) pmmio->adwInfo;
LPSTR szFileName = (LPSTR) lParam1;
HANDLE hModule; // handle to module
HANDLE hResInfo; // handle to resource information
LONG lBytesLeft; // bytes left in res. after current pos.
WORD wBytesAsk; // bytes asked to read
WORD wBytes; // bytes actually read
LONG lBytesTotal; // accum. bytes actually read
LPSTR pchPlus; // pointer to '+'
LPSTR pchDot; // pointer to '.rcd'
LONG lNewOffset;
static LPSTR lpData = "hello world\r\n"; // actual data
switch (uMsg)
{
case MMIOM_OPEN:
if (0 != stricmp(szFileName,"mmiotest.rcd+hello"))
return MMIOERR_CANNOTOPEN;
pInfo->lSize = strlen(lpData);
pInfo->lOffset = 0;
pmmio->lDiskOffset = 0L;
return 0L;
case MMIOM_CLOSE:
return 0L;
case MMIOM_READ:
/* lParam2 = number of bytes to read */
/* lParam1 = address to deliver them to */
lBytesLeft = pInfo->lSize - pmmio->lDiskOffset;
if (lParam2 > lBytesLeft)
lParam2 = lBytesLeft;
// memcpy((LPSTR)lParam1, lpData[pmmio->lDiskOffset], lParam2); but it trapped!
{ int i;
for (i=0; i<lParam2; ++i) {
((LPSTR)lParam1)[i] = lpData[pmmio->lDiskOffset++];
}
}
return lParam2;
case MMIOM_WRITE:
/* Windows resources are read-only */
return -1;
case MMIOM_SEEK:
/* calculate <lNewOffset>, the new offset (relative to the
* beginning of the resource)
*/
switch ((int) lParam2)
{
case SEEK_SET:
lNewOffset = lParam1;
break;
case SEEK_CUR:
lNewOffset = pmmio->lDiskOffset + lParam1;
break;
case SEEK_END:
lNewOffset = pInfo->lSize - lParam1;
break;
}
if (lNewOffset<0)
{ dprintf("Seek to before start of rcd");
return -1;
}
if (lNewOffset>pInfo->lSize)
{ dprintf("Seek to after end of rcd");
return -1;
}
pmmio->lDiskOffset = lNewOffset;
return lNewOffset;
case MMIOM_ANSWER:
/* this I/O procedure knows the answer to the universe */
return lParam1 + lParam2;
}
return 0L;
}
void NEAR PASCAL
Test2(
HWND hwnd)
{
dprintf("Test2 using a DOS file...\n");
Test2Helper(FALSE);
dprintf("Test2 using a memory file...\n");
Test2Helper(TRUE);
}
void NEAR PASCAL
Test2Helper(
BOOL fMemFile)
{
HMMIO hmmio;
HPSTR pchCallerData = NULL;
long lBytesToRead;
long lOffset;
long lBufSize;
long lMemFileBufSize;
BOOL fBuffered;
MMIOINFO mmioinfo;
dprintf("creating 540000-byte file\n");
if (fMemFile)
{
/* create a memory file */
memset(&mmioinfo, 0, sizeof(mmioinfo));
mmioinfo.fccIOProc = FOURCC_MEM;
mmioinfo.pchBuffer = NULL;
mmioinfo.cchBuffer = 12344L; // initial size
mmioinfo.adwInfo[0] = 76543L; // grow by this much
WinEval((hmmio = mmioOpen(NULL, &mmioinfo,
MMIO_CREATE | MMIO_READWRITE)) != NULL);
}
else
{
/* open "test2.tmp" for reading and writing */
WinEval((hmmio = mmioOpen("test2.tmp", NULL,
MMIO_CREATE | MMIO_READWRITE | MMIO_ALLOCBUF)) != NULL);
}
/* create a file that's big enough so we do the following reads:
* 40000, 60000, 80000, 100000, 120000, 140000 (sum 540000)
*/
FillBufferedFile(hmmio, 540000L / 4L);
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 540000L);
dprintf("create huge a buffer that's not segment boundary aligned\n");
/* we'll read stuff into the buffer at offset 12345, to try out
* reading into the buffer across segment offsets
*/
if ((pchCallerData = GAllocPtr(140000L + 12345L)) == NULL)
{
dprintf("test program problem: can't allocate caller buffer\n");
WinAssert(FALSE);
}
lMemFileBufSize = 540000L;
for (fBuffered = fMemFile; fBuffered <= TRUE; fBuffered++)
{
/* seek back */
dprintf("seek back, do 40000-140000 byte %s reads,"
" and check file contents\n",
(LPSTR) (fBuffered ? "buffered" : "unbuffered"));
WinEval(mmioSeek(hmmio, 0L, SEEK_SET) == 0L);
/* read the file in varying large and huge reads, and at the
* same time verify that the file was written to correctly
*/
for (lOffset = 0L, lBytesToRead = 40000L, lBufSize = 100000L;
lBytesToRead <= 140000L;
lOffset += lBytesToRead, lBytesToRead += 20000L,
lBufSize -= 10000L)
{
long lLongs;
long huge * pl;
long lOffsetCheck;
MMIOINFO mmioinfo;
if (fMemFile)
{
/* juggle the memory file buffer around, but
* don't truncate the data
*/
if (lMemFileBufSize == 540000L)
lMemFileBufSize = 678901L;
else
lMemFileBufSize = 540000L;
WinEval(mmioSetBuffer(hmmio, NULL,
lMemFileBufSize, 0) == 0);
}
else
if (fBuffered)
{
/* just to be nasty, let's play around with the
* buffer size while all this is going on
*/
WinEval(mmioSetBuffer(hmmio, NULL, lBufSize, 0)
== 0);
WinEval(mmioGetInfo(hmmio, &mmioinfo, 0) == 0);
WinEval(mmioAdvance(hmmio, &mmioinfo, MMIO_READ)
== 0);
WinEval(mmioSetInfo(hmmio, &mmioinfo, 0) == 0);
}
else
{
/* no buffer */
WinEval(mmioSetBuffer(hmmio, NULL, 0, 0)
== 0);
}
/* read the next <lBytesToRead> */
WinEval(mmioRead(hmmio, pchCallerData + 12345L,
lBytesToRead) == lBytesToRead);
lLongs = lBytesToRead / 4L, pl =
(long huge *) (pchCallerData + 12345L);
lOffsetCheck = lOffset;
while (lLongs-- > 0)
{
WinEval(*pl++ == lOffsetCheck);
lOffsetCheck += 4;
}
}
WinAssert(mmioSeek(hmmio, 0L, SEEK_CUR) == 540000L);
WinAssert(mmioSeek(hmmio, 0L, SEEK_END) == 540000L);
WinEval(mmioRead(hmmio, pchCallerData + 12345L, 17L) == 0L);
}
if (pchCallerData != NULL)
GFreePtr(pchCallerData);
/* close "test2.tmp" */
WinEval(mmioClose(hmmio, 0) == 0);
if (!fMemFile)
{
dprintf("delete the test file using MMIO_DELETE\n");
WinEval(mmioOpen("test2.tmp", NULL, MMIO_DELETE)
== (HANDLE) TRUE);
}
}
void NEAR PASCAL
FillBufferedFile(
HMMIO hmmio,
LONG lLongs)
{
MMIOINFO mmioinfo;
long lOffset = 0;
/* fill buffered file <hmmio> with <lLongs> binary long integers,
* where offset X (such that X % 4 == 0) contains long integer X
*/
/* begin direct access of the I/O buffer */
WinEval(mmioGetInfo(hmmio, &mmioinfo, 0) == 0);
for( ; ; )
{
long lAvail; // bytes available in buffer
lAvail = mmioinfo.pchEndWrite - mmioinfo.pchNext;
for( ; ; )
{
if ((lAvail -= sizeof(lOffset)) < 0)
break;
if (lLongs-- <= 0)
goto EXIT_FUNCTION;
*((long *) mmioinfo.pchNext) = lOffset;
mmioinfo.pchNext = (long)mmioinfo.pchNext + sizeof(long); // bypass compiler bug
lOffset += sizeof(lOffset);
}
/* flush the I/O buffer */
mmioinfo.dwFlags |= MMIO_DIRTY;
WinEval(mmioAdvance(hmmio, &mmioinfo, MMIO_WRITE) == 0);
WinAssert((mmioinfo.pchNext + sizeof(lOffset))
<= mmioinfo.pchEndWrite);
}
EXIT_FUNCTION:
/* end direct access of the I/O buffer */
mmioinfo.dwFlags |= MMIO_DIRTY;
WinEval(mmioSetInfo(hmmio, &mmioinfo, 0) == 0);
/* make sure we're where we think we should be */
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == lOffset);
}
void NEAR PASCAL
Test3(
HWND hwnd)
{
HMMIO hmmio;
DWORD dwFlags;
MMIOINFO mmioinfo;
for (dwFlags = 0; dwFlags <= MMIO_ALLOCBUF; dwFlags += MMIO_ALLOCBUF)
{
WinEval((hmmio = mmioOpen("test3.tmp", NULL,
dwFlags | MMIO_CREATE | MMIO_WRITE)) != NULL);
dprintf("TestRIFF(), %s, MMIO_WRITE: ",
(LPSTR) (dwFlags == 0 ? "unbuffered" : "buffered"));
TestRIFF(hmmio, FALSE);
WinEval(mmioClose(hmmio, 0) == 0);
WinEval((hmmio = mmioOpen("test3.tmp", NULL,
dwFlags | MMIO_CREATE | MMIO_READWRITE)) != NULL);
dprintf("TestRIFF(), %s, MMIO_READWRITE: ",
(LPSTR) (dwFlags == 0 ? "unbuffered" : "buffered"));
TestRIFF(hmmio, TRUE);
WinEval(mmioClose(hmmio, 0) == 0);
}
/* create a memory file */
memset(&mmioinfo, 0, sizeof(mmioinfo));
mmioinfo.fccIOProc = FOURCC_MEM;
mmioinfo.pchBuffer = NULL;
mmioinfo.cchBuffer = 1L; // initial size
mmioinfo.adwInfo[0] = 1L; // grow by this much
WinEval((hmmio = mmioOpen(NULL, &mmioinfo,
MMIO_CREATE | MMIO_READWRITE)) != NULL);
dprintf("TestRIFF() with memory file: ");
TestRIFF(hmmio, TRUE);
WinEval(mmioClose(hmmio, 0) == 0);
dprintf("delete the test file using MMIO_DELETE\n");
WinEval(mmioOpen("test3.tmp", NULL, MMIO_DELETE) == (HANDLE) TRUE);
}
/* Output from TestRIFF():
*
* 00000000 RIFF (0001E32A) 'foo '
* 0000000C abc1 (00000001)
* 00000016 abc2 (00000002)
* 00000020 abc3 (00000003)
* 0000002C abc4 (00000004)
* 00000038 abc5 (00000005)
* 00000046 abc6 (00000006)
* 00000054 abc7 (00000007)
* 00000064 LIST (0000007E) 'data'
* 00000070 num1 (00000001)
* 0000007A num2 (00000002)
* 00000084 num3 (00000003)
* 00000090 num4 (00000004)
* 0000009C num5 (00000005)
* 000000AA num6 (00000006)
* 000000B8 num7 (00000007)
* 000000C8 num8 (00000008)
* 000000D8 num9 (00000009)
* 000000EA xyz (0001E240)
* 0001E332
*/
void NEAR PASCAL
TestRIFF(
HMMIO hmmio,
BOOL fReadable)
{
MMCKINFO ckRIFF;
MMCKINFO ckLIST;
MMCKINFO ck;
HPSTR pchBuf, pchStart;
int huge * pi;
int i;
#define FOURCC_FOO mmioFOURCC('f', 'o', 'o', ' ')
#define FOURCC_ABC mmioFOURCC('a', 'b', 'c', ' ')
#define FOURCC_DATA mmioFOURCC('d', 'a', 't', 'a')
#define FOURCC_NUM mmioFOURCC('n', 'u', 'm', ' ')
#define FOURCC_XYZ mmioFOURCC('x', 'y', 'z', ' ')
dprintf("write file");
/* create 'RIFF' chunk, formtype ' */
ckRIFF.cksize = 0L;
ckRIFF.fccType = FOURCC_FOO;
WinEval(mmioCreateChunk(hmmio, &ckRIFF, MMIO_CREATERIFF) == 0);
/* create chunks 'abc1' ... 'abc7' -- the data for the i-th chunk
* is the first i uppercase letters of the alphabet
*/
for (i = 1; i <= 7; i++)
{
MMCKINFO ck;
ck.ckid = FOURCC_ABC;
((NPSTR) (&ck.ckid))[3] = (CHAR)'0' + (CHAR)i;
ck.cksize = 8 + i;
WinEval(mmioCreateChunk(hmmio, &ck, 0) == 0);
WinEval(mmioWrite(hmmio, "ABCDEFG", (LONG) i) == (LONG) i);
WinEval(mmioAscend(hmmio, &ck, 0) == 0);
}
/* create a LIST chunk with list type 'data' */
ckLIST.cksize = 0L;
ckLIST.fccType = FOURCC_DATA;
WinEval(mmioCreateChunk(hmmio, &ckLIST, MMIO_CREATELIST) == 0);
/* create chunks 'num1' ... 'num9' -- the data for the i-th chunk
* is the first i positive numbers
*/
for (i = 1; i <= 9; i++)
{
ck.ckid = FOURCC_NUM;
((NPSTR) (&ck.ckid))[3] = (CHAR)'0' + (CHAR)i;
ck.cksize = 77; // make medAscend() work for a living
WinEval(mmioCreateChunk(hmmio, &ck, 0) == 0);
WinEval(mmioWrite(hmmio, "123456789", (LONG) i) == (LONG) i);
WinEval(mmioAscend(hmmio, &ck, 0) == 0);
}
/* ascend from the LIST chunk */
WinEval(mmioAscend(hmmio, &ckLIST, 0) == 0);
/* write 'xyz' chunk to contain 123456 bytes that are filled with
* short integers 0 to 123456/2 - 1; make the buffer misaligned
* by 32768 bytes
*/
if ((pchBuf = GAllocPtr(123456L + 32768L)) == NULL)
{
dprintf("test program problem: out of memory\n");
WinAssert(FALSE);
}
pchStart = pchBuf + 32768L;
for (pi = (int huge *) pchStart, i = 0; i < (int) (123456L / sizeof(int)); // (Win32)
pi++, i++)
*pi = i;
ck.ckid = FOURCC_XYZ;
WinEval(mmioCreateChunk(hmmio, &ck, 0) == 0);
WinEval(mmioWrite(hmmio, pchStart, 123456L) == 123456L);
WinEval(mmioAscend(hmmio, &ck, 0) == 0);
/* ascend from the RIFF chunk */
WinEval(mmioAscend(hmmio, &ckRIFF, 0) == 0);
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 0x0001E332L);
/* destroy data in <pchStart>, <ck>, etc. to ensure a
* valid test
*/
#ifdef OMIT
lmemset(pchStart, 12, 123456L);
#else
memset(pchStart, 12, 123456L);
#endif //OMIT
memset(&ckRIFF, 34, sizeof(ckRIFF));
memset(&ckLIST, 56, sizeof(ckLIST));
memset(&ck, 78, sizeof(ck));
if (fReadable)
{
dprintf(", read file");
/* seek back */
WinEval(mmioSeek(hmmio, 0L, SEEK_SET) == 0L);
/* descend into RIFF chunk */
WinEval(mmioDescend(hmmio, &ckRIFF, NULL, 0) == 0);
WinAssert(ckRIFF.ckid == FOURCC_RIFF);
WinAssert(ckRIFF.cksize == 0x0001E32AL);
WinAssert(ckRIFF.fccType == FOURCC_FOO);
WinAssert(ckRIFF.dwDataOffset == 0x00000000L + 8L);
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 0x0000000CL);
/* find all the 'abc' chunks */
for (i = 1; i <= 7; i++)
{
MMCKINFO ck;
char ach[10];
/* seek back to start of RIFF chunk data */
WinEval(mmioSeek(hmmio, 12L, SEEK_SET) == 12L);
ck.ckid = FOURCC_ABC;
((NPSTR) (&ck.ckid))[3] = (CHAR)'0' + (CHAR)i;
WinEval(mmioDescend(hmmio, &ck, &ckRIFF,
MMIO_FINDCHUNK) == 0);
WinAssert(ck.cksize == (UINT)i);
WinAssert(ck.fccType == 0);
WinEval(mmioRead(hmmio, ach, (LONG) i) == (LONG) i);
WinEval(lstrncmp(ach, "ABCDEFG", i) == 0);
if (i != 7)
WinEval(mmioAscend(hmmio, &ck, 0) == 0);
}
/* we're down two levels -- ascend to end of RIFF chunk */
WinEval(mmioAscend(hmmio, &ckRIFF, 0) == 0);
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 0x0001E332L);
/* seek back to start of RIFF chunk data */
WinEval(mmioSeek(hmmio, 12L, SEEK_SET) == 12L);
/* make sure we cannot find 'num1' chunk */
ck.ckid = mmioFOURCC('n', 'u', 'm', '1');
WinEval(mmioDescend(hmmio, &ck, &ckRIFF, MMIO_FINDCHUNK)
== MMIOERR_CHUNKNOTFOUND);
/* seek back to start of RIFF chunk data */
WinEval(mmioSeek(hmmio, 12L, SEEK_SET) == 12L);
/* make sure we can find 'data' list */
ckLIST.fccType = FOURCC_DATA;
WinEval(mmioDescend(hmmio, &ckLIST, &ckRIFF, MMIO_FINDLIST)
== 0);
WinAssert(ckLIST.ckid == FOURCC_LIST);
WinAssert(ckLIST.fccType == FOURCC_DATA);
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 0x00000064L + 12L);
/* descend into each of the 'num' chunks */
for (i = 1; i <= 9; i++)
{
FOURCC fcc;
MMCKINFO ck;
char ach[10];
fcc = FOURCC_ABC;
((NPSTR) (&fcc))[3] = (CHAR)'0' + (CHAR)i;
WinEval(mmioDescend(hmmio, &ck, &ckLIST, 0) == 0);
WinAssert(ck.cksize == (UINT)i);
WinAssert(ck.fccType == 0);
WinEval(mmioRead(hmmio, ach, (LONG) i) == (LONG) i);
WinEval(lstrncmp(ach, "123456789", i) == 0);
WinEval(mmioAscend(hmmio, &ck, 0) == 0);
}
/* make sure we cannot go any further */
WinEval(mmioDescend(hmmio, &ck, &ckLIST, 0)
== MMIOERR_CHUNKNOTFOUND);
/* seek back to start of RIFF chunk data */
WinEval(mmioSeek(hmmio, 12L, SEEK_SET) == 12L);
/* seek to the 'xyz' chunk */
ck.ckid = FOURCC_XYZ;
WinEval(mmioDescend(hmmio, &ck, &ckRIFF, MMIO_FINDCHUNK) == 0);
WinAssert(ck.ckid == FOURCC_XYZ);
WinAssert(ck.fccType == 0);
WinEval(mmioRead(hmmio, pchStart, 123456L) == 123456L);
WinEval(mmioAscend(hmmio, &ck, 0) == 0);
/* ascend from the RIFF chunk */
WinEval(mmioAscend(hmmio, &ckRIFF, 0) == 0);
WinEval(mmioSeek(hmmio, 0L, SEEK_CUR) == 0x0001E332L);
/* check the contents of the 'xyz' chunk */
for (pi = (int huge *) pchStart, i = 0; i < (int) (123456L / sizeof(int)); // (Win32)
pi++, i++)
{
WinAssert(*pi == i);
}
}
GFreePtr(pchBuf);
dprintf(", done.\n");
}
/* sz = lstrrchr(szSrc, ch)
*
* Find the last occurence <sz> (NULL if not found) of <p ch> in <p szSrc>.
*/
LPSTR NEAR PASCAL
lstrrchr(
LPSTR szSrc,
char ch)
{
LPSTR szLast = NULL;
do
{
if (*szSrc == ch)
szLast = szSrc;
} while (*szSrc++ != 0);
return szLast;
}
#ifdef OMIT
/* lmemset(pDst, bSrc, cDst)
*
* Set all <cDest> bytes in memory block <pDst> to a byte value <bSrc>.
*/
void NEAR PASCAL
lmemset(
void far *pDst,
BYTE bSrc,
long cDst)
{
while (cDst-- > 0)
*((BYTE huge *) pDst)++ = bSrc;
}
#endif //OMIT

Reference in a new issue Copy permalink