(physical memory)/(sizeof pointer)

Mark Roddy

This is a KMDF driver.... not a UMDF driver?

Enable WDF Verifier, set Verbose logging, and dump the log with !WDFKD.WDFLOGDUMP

P

Kbdhid as the FDO does not accept USB IO requests. It only accepts HID and kbdclass requests. And even if you sent the request directly to the PDO it would not work as it’s a HID PDO, not a USB enumerated PDO. You can’t get a USB descriptor from where you are in the stack.

Hello gentlemen,

We are using Sysvad example to implement our noise remover.
We made a POC where a user program receives the Sysvad speaker stream and save in a file (insted of the file being saved by the Sysvad itself).
This is working fine.

However we are facing some difficulties to implement the microphone part. We tried to use the same logic as speaker but the result is not working as it should.

What we are doing initially is:

1 - the application sends a 800k buffer to the Sysvad (the WAV file data with 1 channel, 16 bits, 48000hz which is the same as the Sysvad microphone)
2 - in the WriteBytes method we use the ByteDisplacement as the number of bytes we copy from the buffer received to Sysvad m_pDmaBuffer
3 - start the Voice Recorder and record the audio received from the Sysvad microphone

But the recorded sound has poor sound quality, is full of gagging and glitches and at a certain moment, it looks like the noise of a modem connection.
Is there anything else we need to control?

Our WriteBytes implementation:

VOID CMiniportWaveRTStream::WriteBytes
(
    _In_ ULONG ByteDisplacement
)
/*++

Routine Description:
  This function writes the audio buffer using a received buffer from user application

Arguments: 
  ByteDisplacement - # of bytes to process.

--*/
{
    ULONG bufferOffset = m_ullLinearPosition % m_ulDmaBufferSize;
    ULONG runWrite = 0;

    if (m_pExtensionData != NULL && m_pDmaBuffer != NULL) {

        // Is a pointer to buffer's start that persists over each iteration
        // and maps the audio starting point to be sent to the system
        BYTE* sendIni = m_pExtensionData->MicBufferSendIni;

        // Is a pointer to buffer's end that persists over each iteration
        // and maps the audio ending point to be sent to the system
        BYTE* sendEnd = m_pExtensionData->MicBufferSendEnd;

        // maps how many bytes left in the buffer to be sent
        runWrite = (ULONG)(sendEnd - sendIni);

        while (ByteDisplacement > 0)
        {
            // ensure we never read beyond our buffer
            LONG minWrite = min(ByteDisplacement, min(m_ulDmaBufferSize - bufferOffset, runWrite));

            if (minWrite <= 0) {
                break;
            }

            RtlCopyMemory(m_pDmaBuffer + bufferOffset, sendIni, minWrite);
            bufferOffset = (bufferOffset + minWrite) % m_ulDmaBufferSize;
            ByteDisplacement -= minWrite;
            runWrite -= minWrite;

            // slide the pointer to the next piece of buffer to be sent
            sendIni += minWrite;
        }

        // slide the initial position to be sent in the next run 
        m_pExtensionData->MicBufferSendIni = sendIni;
    }
}

Here is the MJ function part that receive the buffer from the application:

{

.....

        // Reading client app input/output buffer information 
        systemBuffer = (BYTE*)_Irp->AssociatedIrp.SystemBuffer;

        // the buffer size informed by the application
        inputBufferLength = stack->Parameters.DeviceIoControl.InputBufferLength;

        //Get pointer to the device extension reserved to store our data (copy of cyclic buffers) 
        ExtensionData = (PNOISE_DATA_STRUCTURE)((PCHAR)_DeviceObject->DeviceExtension + PORT_CLASS_DEVICE_EXTENSION_SIZE);


        if (inputBufferLength > 0 && ExtensionData != NULL && systemBuffer != NULL) {
            DPF(D_TERSE, ("***Input received of %lu bytes", inputBufferLength));

            // copy the received buffer to our structure
            RtlCopyMemory(ExtensionData->MicBuffer, systemBuffer, inputBufferLength);

            // set the relative buffer end (is less or equal buffer size on our example)
            ExtensionData->MicBufferEnd += inputBufferLength;

            // maps the buffer's end position to be read on the WriteBytes function
            ExtensionData->MicBufferSendEnd = ExtensionData->MicBufferEnd;

            bufLen = inputBufferLength;
        }

        _Irp->IoStatus.Information = bufLen;
        _Irp->IoStatus.Status = STATUS_SUCCESS;
        IoCompleteRequest(_Irp, IO_NO_INCREMENT);

        return STATUS_SUCCESS;
        break;

.....
}

Is there any other thing we need to take care?

Thanks in advance!
André Fellows

There is no limit to spin locks. Just be sure you have a locking hierarchy so that you don't get deadlocks of thread 1 holding lock A and trying to get lock B, while thread 2 holds lock B waiting to get lock A.

I was going to start pushing this upward inside the giant tech company I
work for, but I stepped back from that: they aren't going to have a problem
with the policy. Officially all of our drivers are required to be WHQL
signed,so there is nothing to officially complain about. The impact will be
on test and support, and that impact is invisible above a certain level.

I was going to point out that this kills the use of windows embedded as an
RTOS in the DIY/hobbyist world, but that ship sailed a long time ago.

What irks me most is that this is totally unnecessary. What is the net recurring cost to Microsoft of maintaining this capability? Zero. It just seems mean-spirited. I've come to expect this from Apple, but not from Microsoft.

Starting July 2021, can we still sign and install a driver signed with a trusted cross-certificate on a Windows 10 machine...?

No. They are shutting down the whole cross-signing ecosystem. The cross certificates will all expire and no more will be created.