source: sbliveos2/trunk/drv16/dwavestrm.cpp@ 176

/* $Id: dwavestrm.cpp 174 2001-04-14 16:26:09Z sandervl $ */

/* SCCSID = %W% %E% */
/****************************************************************************
 *                                                                          *
 * Copyright (c) IBM Corporation 1994 - 1997.                               *
 *                                                                          *
 * The following IBM OS/2 source code is provided to you solely for the     *
 * the purpose of assisting you in your development of OS/2 device drivers. *
 * You may use this code in accordance with the IBM License Agreement       *
 * provided in the IBM Device Driver Source Kit for OS/2.                   *
 *                                                                          *
 ****************************************************************************/
/**@internal %W%
 * @notes
 * @version %I%
 * @context Unless otherwise noted, all interfaces are Ring-0, 16-bit,
 *  <stack context>.
 * @history
 *
 */
#define INCL_NOPMAPI
#include <os2.h>
#include <os2me.h>
#include <audio.h>

#include <devhelp.h>

#include "dwavestrm.hpp"
#include "memutil.h"
#include <dbgos2.h>
#include "ioctl.h"
#include "malloc.h"

void cdecl HookHandler(ULONG ulSysFileNum)
{
    PDWAVESTREAM pStream;
    PSTREAMBUFFEREX temp;
    int rc;

    pStream = (PDWAVESTREAM)FindStream_fromFile(ulSysFileNum);
    if(pStream == NULL) {
        dprintf(("HookHandler stream %lx not found!", (ULONG) ulSysFileNum));
        DebugInt3();
        return;
    }

    temp = (PSTREAMBUFFEREX)pStream->qhReturn.PopHead();
    while(temp) {
        if(pStream->hSem) {
            rc = DevHelp_PostEventSem(pStream->hSem);
            if(rc != 0) {
                dprintf(("DevHlp_PostEventSem returned %d", rc));
            }
        }
        DevHelp_VMFree((LIN)temp->pBuffptr);
        DevHelp_VMUnLock(temp->linLock);
        delete temp;

        temp = (PSTREAMBUFFEREX)pStream->qhReturn.PopHead();
    }
    return;
}


ULONG DWAVESTREAM::Write(PSTREAMBUF pbuf, ULONG uLength)
{
    PSTREAMBUFFEREX pStreamBuf;
    LIN             linAddr;
    PULONG          pLock;
    ULONG           PageListCount;
    LIN             linLock;
    int             rc;

    pStreamBuf = new STREAMBUFFEREX(uLength, (PSTREAMBUF)0);
    if(pStreamBuf == NULL) {
        DebugInt3();
        return 1;
    }

    pLock = &pStreamBuf->lock[0];

    rc = DevHelp_VirtToLin(SELECTOROF(pLock), OFFSETOF(pLock), &linLock);
    if(rc) {
        DebugInt3();
        delete pStreamBuf;
        return rc;
    }

    rc = DevHelp_VMLock(VMDHL_LONG | VMDHL_WRITE, (LIN)pbuf, uLength, -1L, linLock, (PULONG)&PageListCount);
    if(rc) {
        DebugInt3();
        delete pStreamBuf;
        return rc;
    }

    rc = DevHelp_VMProcessToGlobal(VMDHGP_WRITE, (LIN)pbuf, uLength, (PLIN)&linAddr);
    if(rc) {
        DebugInt3();
        DevHelp_VMUnLock(linLock);
        delete pStreamBuf;
        return rc;
    }
    pStreamBuf->pBuffptr = (PSTREAMBUF)linAddr;
    pStreamBuf->linLock  = linLock;

    return WAVESTREAM::Write((PSTREAMBUFFER)pStreamBuf);
}

void DWAVESTREAM::ReturnBuffer(void)
{
   PSTREAMBUFFEREX temp = (PSTREAMBUFFEREX)qhDone.PopHead();

   if(temp)
   {
        if(ulStreamState == STREAM_STREAMING) {//means we're called during an interrupt
            qhReturn.PushOnTail((PQUEUEELEMENT)temp);
            DevHelp_ArmCtxHook(ulSysFileNum, hCtxHook);
        }
        else {
            DevHelp_VMFree((LIN)temp->pBuffptr);
            DevHelp_VMUnLock(temp->linLock);
            delete temp;
        }
   }
}

ULONG DWAVESTREAM::Register(PDDCMDREGISTER pReg)
{
    hSem = pReg->hStream;

    if(DevHelp_OpenEventSem(hSem) != 0) {
        dprintf(("DevHlp_OpenEventSem %lx failed!", hSem));
        hSem = 0;
        return 1;
    }
    return WAVESTREAM::Register(pReg);
}

void DWAVESTREAM::DeRegister(void)
{
    if(DevHelp_CloseEventSem(hSem) != 0) {
        dprintf(("DevHlp_CloseEventSemaphore %lx failed!", hSem));
        return;
    }
    hSem = 0;
    WAVESTREAM::DeRegister();
}


DWAVESTREAM::DWAVESTREAM(ULONG streamtype, LPMCI_AUDIO_INIT pinit, USHORT filesysnum):
   WAVESTREAM(streamtype, pinit, filesysnum), fError(FALSE), hCtxHook(0), hSem(0)
{
    if(DevHelp_AllocateCtxHook((NPFN)HookHandlerAsm, &hCtxHook)) {
        DebugInt3();
        fError = TRUE;
    }
}

DWAVESTREAM::~DWAVESTREAM()
{
    if (ulStreamState == STREAM_STREAMING) {
        CONTROL_PARM cParm;
        StopStream(&cParm);
    }
    else ReturnBuffers();

    if(hSem) {
        APIRET rc = DevHelp_PostEventSem(hSem);
        if(rc != 0) {
            dprintf(("DevHlp_PostEventSem returned %d", rc));
        }
        if(DevHelp_CloseEventSem(hSem) != 0) {
            dprintf(("DevHlp_CloseEventSemaphore %lx failed!", hSem));
        }
    }
    if(hCtxHook) {
        DevHelp_FreeCtxHook(hCtxHook);
    }
}