自学教程：C++ DPF函数代码示例

void	CTestPage::StartRecord( void )/////////////////////////////////////////////////////////////////////////////{	ULONG	ulBytesRequested, ulCircularBufferSize;	PHALWAVEDEVICE	pHD;	PWAVEFORMATEX	pFormatEx;	if( m_nRecordMode != MODE_STOP )		return;	m_nRecordDevice = m_RecordDevice.GetCurSel();	DPF(("Starting Record Device %d/n", m_nRecordDevice ));	pHD = m_pHalAdapter->GetWaveInDevice( m_nRecordDevice );	// change the button to stop	SetDlgItemText( IDC_RECORD, "Stop" );	if( !m_WaveRecordFile.Open( m_szFileName, MMIO_CREATE | MMIO_READWRITE ) )	{		DPF(("CTestPage::StartRecord Open Failed!/n"));		return;	}	m_WaveRecordFile.SetFormat( WAVE_FORMAT_PCM, 24, 44100, 2 );	pFormatEx = m_WaveRecordFile.GetFormat();	if( !m_WaveRecordFile.WriteHeader() )	{		DPF(("CTestPage::StartRecord WriteHeader Failed!/n"));	}	//DPF(("SetFormat/n"));	pHD->SetFormat( pFormatEx->wFormatTag, pFormatEx->nChannels, pFormatEx->nSamplesPerSec, pFormatEx->wBitsPerSample, pFormatEx->nBlockAlign );	m_lSampleRate = pFormatEx->nSamplesPerSec;	// Get the amount of free space on device	//DPF(("GetTransferSize/n"));	pHD->GetTransferSize( &ulBytesRequested, &ulCircularBufferSize );	ulCircularBufferSize += sizeof(DWORD);	m_pRecordBuffer = malloc( ulCircularBufferSize );	pHD->SetInterruptSamples( (ulCircularBufferSize / sizeof( DWORD )) / 2 );		// put the device in MODE_RUN	//DPF(("Start/n"));	if( pHD->Start() )	{		DPF(("Start Failed!/n"));	}		// advance the hardware pointer so the first interrupt will actually transfer something	pHD->TransferComplete( TRUE );		// set the mode to Recording	m_nRecordMode = MODE_RUN;}

bk3d::Bone*   CPhConstraint::build(TTransformPool *transformPool, const MapMayaCVPtrs &CVPtrs, MapTransform2bk3d &transform2bk3d, bk3d::Bone * pTr, int &childrenOffset, int &effectorOffset){	DPF(("--------------/n"));	size_t nodeByteSize = Bk3dPool::cur_bk3dPool->getUsedSize();    // first time initialization: if 0, it means we must set it to the first constraint    //if(transformPool->offsetConstraints == 0)    //    transformPool->offsetConstraints = transformPool->nBones;    //	// create and copy data	//    m_bk3dConstraint = new TConstraint;    bk3d::Bone	* ttr = CBone::build(transformPool, CVPtrs, transform2bk3d, m_bk3dConstraint, childrenOffset, effectorOffset);    m_bk3dConstraint->pRigidBody1 = NULL; // filled in antoher pass later    m_bk3dConstraint->pRigidBody2 = NULL;    memcpy(m_bk3dConstraint->translation_limit_min, m_translation_limit_min, sizeof(float)*3);    memcpy(m_bk3dConstraint->translation_limit_max, m_translation_limit_max, sizeof(float)*3);    memcpy(m_bk3dConstraint->rotation_limit_min, m_rotation_limit_min, sizeof(float)*3);    memcpy(m_bk3dConstraint->rotation_limit_max, m_rotation_limit_max, sizeof(float)*3);    memcpy(m_bk3dConstraint->spring_constant_translation, m_spring_constant_translation, sizeof(float)*3);    memcpy(m_bk3dConstraint->spring_constant_rotation, m_spring_constant_rotation, sizeof(float)*3);	nodeByteSize = Bk3dPool::cur_bk3dPool->getUsedSize() - nodeByteSize;	m_bk3dConstraint->nodeByteSize = (unsigned int)nodeByteSize;	m_bk3dConstraint->nextNode = (bk3d::Node*)Bk3dPool::cur_bk3dPool->getAvailablePtr(); // next available ptr... not allocated, yet !	DPF(("CPhConstraint sz : %d/n", nodeByteSize));	return m_bk3dConstraint;}

/*===========================================================================*/extern "C" void DrawPrimitiveHAL( PMESAD3DSHARED pShared, D3DPRIMITIVETYPE dptPrimitiveType, D3DTLVERTEX *pVertices, DWORD dwCount ){  PMESAD3DHAL	pHAL = (PMESAD3DHAL)pShared;#ifdef D3D_DEBUG  HRESULT		rc;        DPF(( DBG_FUNC, "DrawPrimitveHAL();" ));  /* Make sure we have enough info. */  if ( (pHAL == NULL) || (pHAL->lpD3DDevice == NULL) )    return;  DPF(( DBG_PRIM_INFO, "DP( %d )", dwCount ));  rc = pHAL->lpD3DDevice->DrawPrimitive( dptPrimitiveType,								 D3DFVF_TLVERTEX,								 (LPVOID)pVertices,								 dwCount, 								 (D3DDP_DONOTCLIP | D3DDP_DONOTLIGHT) );  if ( FAILED(rc) )  {    RIP( pHAL, "DrawPrimitive ->", ErrorStringD3D(rc) );  }#else  pHAL->lpD3DDevice->DrawPrimitive( dptPrimitiveType,							 D3DFVF_TLVERTEX,							 (LPVOID)pVertices,							 dwCount, 							 (D3DDP_DONOTCLIP | D3DDP_DONOTLIGHT) );#endif}

/* * linVidMemInit - initialize video memory manager */static BOOL linVidMemInit( LPVMEMHEAP pvmh, FLATPTR start, FLATPTR end ){    DWORD       size;    DPF( 2, "linVidMemInit(%08lx,%08lx)", start, end );    /*     * get the size of the heap (and verify its alignment for debug builds)     */    size = end - start + 1;    #ifdef DEBUG	if( (size & (BLOCK_BOUNDARY-1)) != 0 )	{	    DPF( 1, "Invalid size: %08lx (%ld)/n", size, size );	    return FALSE;	}    #endif    /*     * set up a free list with the whole chunk of memory on the block     */    pvmh->freeList = MemAlloc( sizeof( VMEML ) );    if( pvmh->freeList == NULL )    {	return FALSE;    }    ((LPVMEML)pvmh->freeList)->next = NULL;    ((LPVMEML)pvmh->freeList)->ptr = start;    ((LPVMEML)pvmh->freeList)->size = size;    pvmh->allocList = NULL;    return TRUE;} /* linVidMemInit */

intmain(int argc, char *argv[])#endif{	struct lock_msg message_buf;	daemonaddr_t from;	int addrlen;	int rc;	int x = 1;		/* kludge to stop warnings from compiler */	init(argc, argv);	CRIT_BEGIN();	while (x) {		CRIT_END();		addrlen = sizeof (from);		DPF((stderr, "begin recvfrom/n"));		rc = recvfrom(lock_soc, &message_buf, sizeof (message_buf),		    0, (struct sockaddr *)&from, &addrlen);		DPF((stderr, "end recvfrom rc = %d/n", rc));		CRIT_BEGIN();		if (rc == sizeof (message_buf))			dispatch(&message_buf, &from);		else			check_for_write_lock();		/* if we own the lock, check to see if the process died */		if (the_lock.type != LOCK_NOTLOCKED &&		    the_lock.remote_daemon == NULL)			check_for_dead();	}	CRIT_END();	return (0);}

int emu10k1_mpuin_start(struct emu10k1_card *card){	struct emu10k1_mpuin *card_mpuin = card->mpuin;	u8 dummy;	DPF(2, "emu10k1_mpuin_start()/n");	/* Set timestamp if not set */	if (card_mpuin->status & FLAGS_MIDM_STARTED) {		DPF(2, "Time Stamp not changed/n");	} else {		while (!emu10k1_mpu_read_data(card, &dummy));		card_mpuin->status |= FLAGS_MIDM_STARTED;	/* set */		/* Set new time stamp */		card_mpuin->timestart = (jiffies * 1000) / HZ;		DPD(2, "New Time Stamp = %d/n", card_mpuin->timestart);		card_mpuin->qhead = 0;		card_mpuin->qtail = 0;		emu10k1_irq_enable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE);	}	return 0;}

// returns the size (number of bytes) in an X64 functionULONG Getx64FunctionSize (     PVOID Function ){    PIMAGE_RUNTIME_FUNCTION_ENTRY  RuntimeFunction;    ULONGLONG ImageBase = 0;    ULONG FunctionSize = 0;    // RtlLookupFunctionEntry() locates the start and end of the function    // using the X64 exception table information in the PE file    // RtlLookupFunctionEntry() is only available on X64 systems    // using it makes this this module incompatible with x86 systems    RuntimeFunction = (PIMAGE_RUNTIME_FUNCTION_ENTRY)RtlLookupFunctionEntry(        (ULONGLONG)Function,        &ImageBase,        NULL );    // if there is no valid runtime entry structure then the extents of     // the functions cannot be determined    if ( ! RuntimeFunction ) {        DPF(("%s!%s RtlLookupFunctionEntry(%p)/n", __MODULE__, __FUNCTION__,             Function ));        goto Exit;    }    // compute the number of functions in the function body based on the     // functions extents, note this logic will not work for BBT'd functions    FunctionSize = RuntimeFunction->EndAddress - RuntimeFunction->BeginAddress;    DPF(("%s!%s PRUNTIME_FUNCTION(BeginAddress=0x%08x EndAddress=0x%08x) Size=%u/n", __MODULE__, __FUNCTION__,        RuntimeFunction->BeginAddress, RuntimeFunction->EndAddress, FunctionSize ));Exit :    return FunctionSize;} // Getx64FunctionSize()

NDIS_STATUS DriverEntry(    IN  PDRIVER_OBJECT      DriverObject,    IN  PUNICODE_STRING     RegistryPath ){    NDIS_FILTER_DRIVER_CHARACTERISTICS  FilterCharacteristics;    NDIS_STATUS NdisStatus;    DPF(("%s!%s DriverObject=%p RegistryPath=%wZ/n", __MODULE__, __FUNCTION__,         DriverObject, RegistryPath ));     DriverObject->DriverUnload = DriverUnload;    GlobalNDISLWF.FilterDriverHandle = NULL;    // Setup the FilterCharacteristics structure    // Handlers implemented by the driver are :    // AttachHandler, DetachHandler, RestartHandler, PauseHandler, StatusHandler    // ReceiveNetBufferListsHandler, ReturnNetBufferListsHandler    NdisZeroMemory(&FilterCharacteristics, sizeof(NDIS_FILTER_DRIVER_CHARACTERISTICS));    FilterCharacteristics.Header.Type = NDIS_OBJECT_TYPE_FILTER_DRIVER_CHARACTERISTICS;    FilterCharacteristics.Header.Size = sizeof(NDIS_FILTER_DRIVER_CHARACTERISTICS);    FilterCharacteristics.Header.Revision = NDIS_FILTER_CHARACTERISTICS_REVISION_1;    FilterCharacteristics.MajorNdisVersion = NDISLWF_NDIS_MAJOR_VERSION;    FilterCharacteristics.MinorNdisVersion = NDISLWF_NDIS_MINOR_VERSION;    FilterCharacteristics.MajorDriverVersion = NDISLWF_DRIVER_MAJOR_VERSION;    FilterCharacteristics.MinorDriverVersion = NDISLWF_DRIVER_MINOR_VERSION;    FilterCharacteristics.Flags = 0;    NdisInitUnicodeString ( &FilterCharacteristics.FriendlyName, NDISLWF_FRIENDLY_NAME );    NdisInitUnicodeString ( &FilterCharacteristics.UniqueName, NDISLWF_UNIQUE_NAME);    NdisInitUnicodeString ( &FilterCharacteristics.ServiceName, NDISLWF_SERVICE_NAME);    FilterCharacteristics.AttachHandler = NDISLWF_AttachHandler;    FilterCharacteristics.DetachHandler = NDISLWF_DetachHandler;    FilterCharacteristics.RestartHandler = NDISLWF_RestartHandler;    FilterCharacteristics.PauseHandler = NDISLWF_PauseHandler;    FilterCharacteristics.StatusHandler = NDISLWF_StatusHandler;    FilterCharacteristics.ReceiveNetBufferListsHandler = NDISLWF_ReceiveNetBufferListsHandler;    FilterCharacteristics.ReturnNetBufferListsHandler = NDISLWF_ReturnNetBufferListsHandler;    // Register the filter driver using the FilterCharacteristics structure    // NdisFRegisterFilterDriver())    NdisStatus = NdisFRegisterFilterDriver(        DriverObject,        (NDIS_HANDLE)DriverObject, // no driver-wide context        &FilterCharacteristics,         &GlobalNDISLWF.FilterDriverHandle);    if (NdisStatus != NDIS_STATUS_SUCCESS) {        DPF(("%s!%s NdisFRegisterFilterDriver() FAIL=%08x/n", __MODULE__, __FUNCTION__, NdisStatus));        goto Exit1;    }    DPF(("%s!%s NdisFRegisterFilterDriver() FilterDriverHandle=%p/n", __MODULE__, __FUNCTION__,         GlobalNDISLWF.FilterDriverHandle )); Exit1 :    return NdisStatus;}

static intcmp_addr(daemonaddr_t *a, daemonaddr_t *b){	int rc;	rc = memcmp(&(a->sin_addr), &(b->sin_addr), sizeof (a->sin_addr));	DPF((stderr, "compare %s %hu with", dp_addr(a), a->sin_port));	DPF((stderr, " %s %hu = %d/n", dp_addr(b), b->sin_port, rc));	return (rc);}

/*===========================================================================*/extern "C" void SwapBuffersHAL( PMESAD3DSHARED pShared ){  PMESAD3DHAL	pHAL = (PMESAD3DHAL)pShared;#ifdef D3D_DEBUG  HRESULT		rc;        DPF(( DBG_FUNC, "SwapBuffersHAL();" ));  DPF(( DBG_ALL_PROFILE, "=================SWAP===================" ));  /* Make sure we have enough info. */  if ( (pHAL == NULL) || (pHAL->lpD3DDevice == NULL) )    return;  /* Make sure we have enough info. */  if ( pHAL->lpDDSPrimary != NULL )  {    rc = pHAL->lpD3DDevice->EndScene();       if ( FAILED(rc) )    {	 RIP( pHAL, "EndScene ->", ErrorStringD3D(rc) );    }     if ( pShared->bFlipable )    {	 DPF(( DBG_CNTX_PROFILE, "Swap->FLIP" ));	 rc = pHAL->lpDDSPrimary->Flip( NULL, DDFLIP_WAIT );    }    else    {	 DPF(( DBG_CNTX_PROFILE, "Swap->Blt" ));	 rc = pHAL->lpDDSPrimary->Blt( &pShared->rectW, pHAL->lpDDSRender, NULL, DDBLT_WAIT, NULL );    }    if ( FAILED(rc) )    {	 RIP( pHAL, "Blt (RENDER/PRIMARY) ->", ErrorStringD3D(rc) );    }    rc = pHAL->lpD3DDevice->BeginScene();     if ( FAILED(rc) )    {	 RIP( pHAL, "BeginScene ->", ErrorStringD3D(rc) );    }  }#else  pHAL->lpD3DDevice->EndScene();     if ( pShared->bFlipable )    pHAL->lpDDSPrimary->Flip( NULL, DDFLIP_WAIT );  else    pHAL->lpDDSPrimary->Blt( &pShared->rectW, pHAL->lpDDSRender, NULL, DDBLT_WAIT, NULL );  pHAL->lpD3DDevice->BeginScene(); #endif}

/*! ************************************************ @function SGXUT_decode_build_options @description	Describe the build options returned from microkernel				 (SGXGetMiscInfo) query @input		IMG_UINT32 : build options @input		IMG_UINT32 : mask @output	none ************************************************ */static IMG_VOID SGXUT_decode_build_option(IMG_UINT32 ui32In, IMG_UINT32 ui32Mask){	if ( (ui32In & ui32Mask) != 0)	{		DPF("enabled/n");	}	else	{		DPF("disabled/n");	}}

VOIDDriverUnload (    PDRIVER_OBJECT DriverObject ){    DPF(("%s!%s DriverObject=%p/n", __MODULE__, __FUNCTION__,         DriverObject ));     // Deregister the filter driver (NdisFDeregisterFilterDriver())    NdisFDeregisterFilterDriver(GlobalNDISLWF.FilterDriverHandle);    DPF(("***** DRIVER UNLOADED *****/n")); }

/*!****************************************************************************** @Function	print_sgx_info @Description Print info about the passed PVRSRV_SGX_CLIENT_INFO structure to stdout @Input    *psSGXInfo : @Return   void  :******************************************************************************/static void print_sgx_info(PVRSRV_SGX_CLIENT_INFO *psSGXInfo){	/*		Add anything interesting from the SGX info structure here.	*/	DPF(".... ui32ProcessID:%u/n", psSGXInfo->ui32ProcessID);}

int emu10k1_mpuin_open(struct emu10k1_card *card, struct midi_openinfo *openinfo){	struct emu10k1_mpuin *card_mpuin = card->mpuin;	DPF(2, "emu10k1_mpuin_open/n");	if (!(card_mpuin->status & FLAGS_AVAILABLE))		return -1;	/* Copy open info and mark channel as in use */	card_mpuin->openinfo = *openinfo;	card_mpuin->status &= ~FLAGS_AVAILABLE;	/* clear */	card_mpuin->status |= FLAGS_READY;	/* set */	card_mpuin->status &= ~FLAGS_MIDM_STARTED;	/* clear */	card_mpuin->firstmidiq = NULL;	card_mpuin->lastmidiq = NULL;	card_mpuin->qhead = 0;	card_mpuin->qtail = 0;	sblive_miStateInit(card_mpuin);	emu10k1_mpu_reset(card);	emu10k1_mpu_acquire(card);	return 0;}

void emu10k1_wavein_close(struct emu10k1_wavedevice *wave_dev){	struct emu10k1_card *card = wave_dev->card;	struct wiinst *wiinst = wave_dev->wiinst;	unsigned long flags;	DPF(2, "emu10k1_wavein_close()/n");	emu10k1_wavein_stop(wave_dev);	emu10k1_timer_uninstall(card, &wiinst->timer);	free_buffer(card, &wiinst->buffer);	spin_lock_irqsave(&card->lock, flags);	switch (wave_dev->wiinst->recsrc) {	case WAVERECORD_AC97:		card->wavein.ac97 = NULL;		break;	case WAVERECORD_MIC:		card->wavein.mic = NULL;		break;	case WAVERECORD_FX:		card->wavein.fx = NULL;		break;	default:		BUG();		break;	}	spin_unlock_irqrestore(&card->lock, flags);	wiinst->state = WAVE_STATE_CLOSED;}

static int sblive_miState2ByteKey(struct emu10k1_mpuin *card_mpuin, u8 data)/* byte 1 */{	unsigned long tmp;	if (data > 0x7f) {		/* Real-time messages check */		if (data > 0xf7)			return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);		/* Invalid data! */		DPF(2, "Invalid data!/n");		card_mpuin->curstate = STIN_PARSE;		tmp = (unsigned long) data;		tmp = tmp << 8;		tmp |= (unsigned long) card_mpuin->status;		emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);		return -1;	}	card_mpuin->curstate = STIN_2BYTE;	tmp = (unsigned long) data;	tmp = tmp << 8;	tmp |= (unsigned long) card_mpuin->status;	emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATA, tmp, 2);	return 0;}

static int sblive_miStateSysCommon3Key(struct emu10k1_mpuin *card_mpuin, u8 data)/* byte 1 */{	unsigned long tmp;	if (data > 0x7f) {		/* Real-time messages check */		if (data > 0xf7)			return midistatefn[STIN_SYS_REAL].Fn(card_mpuin, data);		/* Invalid data! */		DPF(2, "Invalid data!/n");		card_mpuin->curstate = card_mpuin->laststate;		tmp = (unsigned long) data;		tmp = tmp << 8;		tmp |= (unsigned long) card_mpuin->fstatus;		emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INDATAERROR, tmp, 0);		return -1;	}	card_mpuin->data = data;	card_mpuin->curstate = STIN_SYS_COMMON_3_VEL;	return CTSTATUS_NEXT_BYTE;}

void emu10k1_voices_stop(struct emu_voice *first_voice, int num_voices){	struct emu10k1_card *card = first_voice->card;	struct emu_voice *voice;	unsigned int voice_num;	int j;	DPF(2, "emu10k1_voice_stop()/n");        for (voice_num = 0; voice_num < num_voices; voice_num++)	{		voice = first_voice + voice_num;		for (j = 0; j < (voice->flags & VOICE_FLAGS_STEREO ? 2 : 1); j++) {			sblive_writeptr_tag(card, voice->num + j,						PTRX_PITCHTARGET, 0,						CPF_CURRENTPITCH, 0,						IFATN, 0xffff,						VTFT, 0x0000ffff,						CVCF, 0x0000ffff,						IP, 0,						TAGLIST_END);		}	}}

/* exist, send it up to IMIDI level.                            */int emu10k1_mpuin_reset(struct emu10k1_card *card){	struct emu10k1_mpuin *card_mpuin = card->mpuin;	struct midi_queue *midiq;	DPF(2, "emu10k1_mpuin_reset()/n");	emu10k1_irq_disable(card, card->is_audigy ? A_INTE_MIDIRXENABLE : INTE_MIDIRXENABLE);	while (card_mpuin->firstmidiq) {		midiq = card_mpuin->firstmidiq;		card_mpuin->firstmidiq = midiq->next;		if (midiq->sizeLeft == midiq->length)			emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGDATA, (unsigned long) midiq, 0);		else			emu10k1_mpuin_callback(card_mpuin, ICARDMIDI_INLONGERROR, (unsigned long) midiq, 0);		kfree(midiq);	}	card_mpuin->lastmidiq = NULL;	card_mpuin->status &= ~FLAGS_MIDM_STARTED;	return 0;}

void emu10k1_voice_free(struct emu_voice *voice){	struct emu10k1_card *card = voice->card;	int i;	unsigned long flags;	DPF(2, "emu10k1_voice_free()/n");	if (voice->usage == VOICE_USAGE_FREE)		return;	for (i = 0; i < (voice->flags & VOICE_FLAGS_STEREO ? 2 : 1); i++) {		DPD(2, " voice released -> %d/n", voice->num + i);		sblive_writeptr_tag(card, voice->num + i, DCYSUSV, 0, 							VTFT, 0x0000ffff,							PTRX_PITCHTARGET, 0,							CVCF, 0x0000ffff,							//CPF, 0,							TAGLIST_END);				sblive_writeptr(card, CPF, voice->num + i, 0);	}	voice->usage = VOICE_USAGE_FREE;	spin_lock_irqsave(&card->lock, flags);	card->voicetable[voice->num] = VOICE_USAGE_FREE;	if (voice->flags & VOICE_FLAGS_STEREO)		card->voicetable[voice->num + 1] = VOICE_USAGE_FREE;	spin_unlock_irqrestore(&card->lock, flags);}

static voidcheck_for_write_lock(){	struct lockdaemon *ldp;	int i;	int	wait = 0;	DPF((stderr, "check for lock/n"));	if (lock_wanted.state != STATE_ASKED)		return;	for (i = 0, ldp = daemon_list; i < MAX_DAEMONS; i++, ldp++) {		if (ldp->inuse == 0)			break;		if (ldp->up && ldp->state != STATE_OKAYED) {			wait = 1;			break;		}	}	if (wait == 0 && lock_wanted.type == LOCK_WRITE) {		the_lock.type = LOCK_WRITE;		the_lock.holding_pid[0] = lock_wanted.pid;		the_lock.nholders = 1;		the_lock.state = STATE_CLEAR;		take_lock(LOCK_LOCKED);	}}

/* * GetPtr16 */LPVOID GetPtr16( LPVOID ptr ){    DWORD       diff;    DWORD       p16;    LPSELLIST   psel;    LPBYTE      lptr;    lptr = ptr;    psel = lpSelList;    while( psel != NULL )    {	if( psel->base <= lptr )	{	    diff = lptr - psel->base;	    if( diff <= 0xf000 )	    {		p16 = ((DWORD)psel->sel << 16l) + diff;		return (LPVOID) p16;	    }	}	psel = psel->link;    }    DPF( 1, "ERROR: NO 16:16 PTR for %08lx", lptr );    return NULL;} /* GetPtr16 */

CMiniportWaveCyclicStreamMSVAD::SetBufferSize(    IN ULONG                    BufferSize)/*++Routine Description:  The SetBufferSize function sets the current buffer size. This value is set to  the allocated buffer size when AllocateBuffer is called. The DMA object does  not actually use this value internally. This value is maintained by the object  to allow its various clients to communicate the intended size of the buffer.  Callers of SetBufferSize can run at any IRQL.Arguments:  BufferSize - Current size in bytes.Return Value:  void--*/{	DPF_ENTER(("[CMiniportWaveCyclicStreamMSVAD::SetBufferSize]"));    if ( BufferSize <= m_ulDmaBufferSize )    {        m_ulDmaBufferSize = BufferSize;    }    else    {        DPF(D_ERROR, ("Tried to enlarge dma buffer size"));    }} // SetBufferSize

USHORT	CHalWaveDevice::SetFormat( USHORT wFormatTag, LONG lChannels, LONG lSampleRate, LONG lBitsPerSample, LONG lBlockAlign )// This doesn't actually touch the hardware - all format changes are done// when the device goes into RUN mode./////////////////////////////////////////////////////////////////////////////{	USHORT	usStatus;	//DPF(("CHalWaveDevice::SetFormat/n"));	// must check to see if device is idle first	if( m_usMode != MODE_STOP )	{		DPF(("CHalWaveDevice::SetFormat: Device Not IDLE!/n"));		return( HSTATUS_INVALID_MODE );	}		// make sure this is a valid format	usStatus = ValidateFormat( wFormatTag, lChannels, lSampleRate, lBitsPerSample, lBlockAlign );	if( usStatus )		return( usStatus );	// remember the format for our device	m_wFormatTag		= wFormatTag;	m_lNumChannels		= lChannels;	m_lSampleRate		= lSampleRate;	m_lBitsPerSample	= lBitsPerSample;	m_lBytesPerBlock	= lBlockAlign;	return( HSTATUS_OK );}

USHORT	FindAdapter( PVOID pContext, PPCI_CONFIGURATION pPCI )// Called from the Hal/////////////////////////////////////////////////////////////////////////////{#ifdef USEHARDWARE	// Start with the LynxTWO-A	pPCI->usDeviceID = PCIDEVICE_LYNXTWO_A;	if( !FindPCIDevice( pPCI ) )	{		pPCI->usDeviceID = PCIDEVICE_LYNXTWO_B;		if( !FindPCIDevice( pPCI ) )		{			pPCI->usDeviceID = PCIDEVICE_LYNXTWO_C;			if( !FindPCIDevice( pPCI ) )			{				pPCI->usDeviceID = PCIDEVICE_LYNX_L22;				if( !FindPCIDevice( pPCI ) )				{					DPF(("FindPCIDevice Failed!"));					return( HSTATUS_CANNOT_FIND_ADAPTER );				}			}		}	}#endif	return( HSTATUS_OK );}

/* * InsertIUnknown * * Insert a new IUnknown with its associated IID into the IUnknown list of the * given surface. */static LPIUNKNOWN_LIST InsertIUnknown(			    LPDDRAWI_DDRAWSURFACE_LCL pThisLCL,			    REFIID riid,			    IUnknown FAR *lpIUnknown){    LPIUNKNOWN_LIST lpIUnknownNode;    DPF( 4, "Adding aggregated IUnknown %x", lpIUnknown );        lpIUnknownNode = ( LPIUNKNOWN_LIST ) MemAlloc( sizeof( IUNKNOWN_LIST ) );    if( lpIUnknownNode == NULL )	return NULL;    lpIUnknownNode->lpGuid = ( GUID FAR * ) MemAlloc( sizeof( GUID ) );    if( lpIUnknownNode->lpGuid == NULL )    {	MemFree( lpIUnknownNode );	return NULL;    }    memcpy( lpIUnknownNode->lpGuid, riid, sizeof( GUID ) );    lpIUnknownNode->lpLink            = pThisLCL->lpSurfMore->lpIUnknowns;    lpIUnknownNode->lpIUnknown        = lpIUnknown;    pThisLCL->lpSurfMore->lpIUnknowns = lpIUnknownNode;    return lpIUnknownNode;}

static int pt_putblock(struct emu10k1_wavedevice *wave_dev, u16 *block, int nonblock){	struct woinst *woinst = wave_dev->woinst;	struct emu10k1_card *card = wave_dev->card;	struct pt_data *pt = &card->pt;	u16 *ptr = (u16 *) card->tankmem.addr;	int i = 0, r;	unsigned long flags;	r = pt_wait_for_write(wave_dev, nonblock);	if (r < 0)		return r;	spin_lock_irqsave(&card->pt.lock, flags);	while (i < PT_BLOCKSAMPLES) {		pt_putsamples(pt, ptr, block[2*i], block[2*i+1]);		if (pt->copyptr == 0)			pt->copyptr = PT_SAMPLES;		pt->copyptr--;		i++;	}	woinst->total_copied += PT_BLOCKSIZE;	pt->blocks_copied++;	if (pt->blocks_copied >= 4 && pt->state != PT_STATE_PLAYING) {		DPF(2, "activating digital pass-through playback/n");		sblive_writeptr(card, GPR_BASE + pt->enable_gpr, 0, 1);		pt->state = PT_STATE_PLAYING;	}	spin_unlock_irqrestore(&card->pt.lock, flags);	return 0;}

/*------------------------------------------------------------------	Transforms  ------------------------------------------------------------------*/size_t	CPhConstraint::getTotalSize(int &relocationSlots){	relocationSlots += getNumRelocationSlots();	size_t sz = sizeof(bk3d::Constraint);	DPF(("Constraint : %d/n", sz));	return sz;}