So, what can you do to workaround this?

I would suggest you to use a different subtype for your custom format and register your decryptor to handle that format.   This may require you to decrypt and decode in the same MFT.

Third party applications are open to use both Dolby Audio Decoder MFT and Dolby Digital Audio Encoder MFT on Windows 8. Our MSDN documentation had some confusion about uses of these two MFTs, but recently we have updated it to clarify the confusion.

Workaround: The problem is actually in the audiodg.exe. When someone pull the plug of a USB audio capture device in the middle of the audio capture session, it releases the audio driver handle without waiting for the recording application to finish all of its cleanup job. This behavior doesn’t exist on Windows 8.

You can bypass this problem by using WASAPI in event driven mode. It is actually far better than timer mode and highly recommended for the applications those require low latency. I have attached a sample application to demonstrate this workaround.

Your questions:

How to use mmioDescend(), mmioRead() with CreateFile()? or how to pass the regular FILE hander created by CreateFile() to mmioRead()?

Answer:

You cannot use the handle returned by the CreateFile API with any of the mmio* APIs. Here is the code snippet that will show you how to open a wave file (RIFF format) and parse the file header without using mmio* APIs.

// FileHeader will receive all the information in the file header and
// in the header of the format chunk.

typedef struct
{
    ULONG Riff4CC;      // "RIFF" 4-character code
    ULONG FileSize;     // total file size in bytes
    ULONG Wave4CC;      // "WAVE" 4-character code
    ULONG Fmt4CC;       // "fmt " 4-character code
    ULONG FormatSize;   // wave format size in bytes
} FileHeader;

// ChunkHeader will receive the information in the headers for the data
// chunks, and, if the file contains additional chunks, the headers for 
// those chunks as well.

typedef struct
{
    ULONG ChunkType;
    ULONG ChunkSize;
} ChunkHeader;
// Any file smaller than this cannot possibly contain wave data.
#define MIN_WAVE_FILE_SIZE (sizeof(FileHeader)+sizeof(PCMWAVEFORMAT)+sizeof(ChunkHeader)+1)

// Macro to build FOURCC from first four characters in ASCII string
#define FOURCC(s)  ((ULONG)(s[0] | (s[1]<<8) | (s[2]<<16) | (s[3]<<24)))
//
//-- Open wave file and parse file header.
 
//
void WaveFileReader(LPCWSTR pszFileName, BOOL repeat)
{
    FILE pFile = NULL;
    HRESULT hrStreamStatus = S_OK;
    fpos_t dataChunkPosition = 0;
    ULONG totalDataBytes = 0;
    ULONG dataBytesRemaining = 0;
    WAVEFORMATEXTENSIBLE wfx;
    BOOL repeatMode = repeat;

    ZeroMemory(&wfx, sizeof(wfx));

    // Try to open the wave file.
    if (_wfopen_s(&pFile, pszFileName, L"rb") != 0)
    {
        _tprintf(L"[ERROR] Failed to open file!...Exiting\n\n");
        return;
    }

    // Copy header from wave file.
    FileHeader fileHdr;

   if (fread(&fileHdr, sizeof(fileHdr), 1, pFile) != 1)
    {
        _tprintf(L"[ERROR] Not a valid wave file!...Exiting\n\n");
        return;
    }

       if (fileHdr.Riff4CC != FOURCC("RIFF")) 
       {
              _tprintf(L"[WARNING] RIFF signature: Not Found\n");
       } else {
              _tprintf(L"RIFF signature: Found\n");
       }

       if (fileHdr.Wave4CC != FOURCC("WAVE"))
       {
              _tprintf(L"[WARNING] WAVE signature: Not Found\n");           
       } else {
              _tprintf(L"WAVE signature: Found\n");           
       }

       if (fileHdr.Fmt4CC != FOURCC("fmt "))
       {
              _tprintf(L"[WARNING] fmt  signature: Not Found\n");           
       } else {
              _tprintf(L"fmt  signature: Found\n");           
       }

       if (fileHdr.FileSize < MIN_WAVE_FILE_SIZE)
       {
              _tprintf(L"[WARNING] File size: %d (Minimum WAV file size supported is %d)\n", fileHdr.FileSize, MIN_WAVE_FILE_SIZE);          
       
       } else {
              _tprintf(L"File size: %d\n", fileHdr.FileSize);        
       }


       if (fileHdr.FormatSize < sizeof(PCMWAVEFORMAT))
       {
              _tprintf(L"[WARNING] Format size: %d (Smaller than size of PCMWAVEFORMAT %d)\n", fileHdr.FormatSize, sizeof(PCMWAVEFORMAT));            

       } else {
              _tprintf(L"Format size: %d\n", fileHdr.FormatSize);                  
       }

    // Copy wave format descriptor from file.
    if (fread(&wfx, min(fileHdr.FormatSize,sizeof(wfx)), 1, pFile) != 1)
    {
        _tprintf(L"[ERROR] Failed to copy wave format descriptor from the file!...Exiting\n\n");
        return;
    }

    // Skip over any padding at the end of the format in the format chunk.
    if (fileHdr.FormatSize > sizeof(wfx))
    {
        if (fseek(pFile, fileHdr.FormatSize-sizeof(wfx), SEEK_CUR) != 0)
        {
            _tprintf(L"[ERROR] Failed to skip over any padding at the end of the format in the format chunk!...Exiting\n\n");
            return;  // not a valid wave file
        }
    }

    // If format type is PCMWAVEFORMAT, convert to valid WAVEFORMATEX structure.
    if (wfx.Format.wFormatTag == WAVE_FORMAT_PCM)
    {
        wfx.Format.cbSize = 0;
    }

    // If format type is PCMWAVEFORMAT, convert to valid WAVEFORMATEX structure.
    if (wfx.Format.wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
    {
        wfx.Format.cbSize = 0;
    }

    // If format type is WAVEFORMATEX, convert to WAVEFORMATEXTENSIBLE.
    if (wfx.Format.wFormatTag == WAVE_FORMAT_PCM ||
        wfx.Format.wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
    {
        if (wfx.Format.wFormatTag == WAVE_FORMAT_PCM)
        {
             wfx.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
        }
        else
        {
             wfx.SubFormat = KSDATAFORMAT_SUBTYPE_IEEE_FLOAT;
        }
        

        wfx.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;

            
        if (wfx.Format.nChannels == 1)
        {
             wfx.dwChannelMask = SPEAKER_FRONT_CENTER;
        }
        else if (wfx.Format.nChannels == 2)
        {
             wfx.dwChannelMask = SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT;
        }
        else
        {
            _tprintf(L"[WARNING] WAVEFORMATEX structure is valid for representing wave formats with only 1 or 2 channels!...Exiting\n\n");    
            return;
        }
        
              wfx.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
              
              _tprintf(L"cbSize (Format.cbSize): %d\n", wfx.Format.cbSize);            
              
              _tprintf(L"Valid bits per sample (Samples.wValidBitsPerSample): %d\n", wfx.Format.wBitsPerSample);            

              wfx.Samples.wValidBitsPerSample = wfx.Format.wBitsPerSample;
    }

    // This wave file reader understands only PCM and IEEE float formats.
    if (wfx.Format.wFormatTag != WAVE_FORMAT_EXTENSIBLE ||
        wfx.SubFormat != KSDATAFORMAT_SUBTYPE_PCM &&
        wfx.SubFormat != KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)
    {
  
        _tprintf(L"[WARNING] Not a format that we can handle...Exiting\n\n");    
        return;
    }
       

    _tprintf (L"\tTrying to read wave data chunk header...\n");
    
    
    ChunkHeader chunkHdr;   // buffer for chunk header
    for (;;)
    {
    
        if (fgetpos(pFile, &dataChunkPosition) != 0)
        {
            _tprintf(L"\t[ERROR] Failed to retrive data chunk position!...Exiting\n\n");
            return;
        }

        // Read header at start of next chunk of file.
        if (fread(&chunkHdr, sizeof(ChunkHeader), 1, pFile) != 1)
        {
            _tprintf(L"\t[ERROR] Failed to read header!...Exiting\n\n");
             return;
        }
        
        if (chunkHdr.ChunkType == FOURCC("data"))
        {
            _tprintf(L"\tFound start of the data chunk\n");
             break;  // found start of data chunk
        }
        
        _tprintf (L"\tVerifying data chunk...");

              // This is not a data chunk. Skip this chunk and go to the next chunk.
        if (fseek(pFile, chunkHdr.ChunkSize, SEEK_CUR) != 0)
        {
            _tprintf (L"\t[ERROR] Invalid data chunk!...Exiting\n\n");    
            return;
        } else {
           _tprintf (L"done!\n");
        }
    }

    // We've found the start of the data chunk.    
    totalDataBytes = chunkHdr.ChunkSize;
    dataBytesRemaining = totalDataBytes;

    _tprintf(L"Total data bytes: %d\n", totalDataBytes);

    if (totalDataBytes == 0)
    {
        _tprintf(L"[ERROR] Invalid data bytes size!...Exiting\n\n");
        return;
    }
       
}
  

Resolution:

You have to give additional permissions to the WMS COM object using DCOM Config (DCOMCNFG.EXE) to fix the issue. You can enable all the elements of the security tab of the DCOM Config following the steps below:

1. Open the Component Services Management tool

2. Go to "Console Root"->"Component Services"->"Computers"->"My Computers"->"DCOM Config"

3. Now right click on the "Windows Media Services" and select "Properties"

4. From the "General" tab copy the "Application ID"

5. Open "Registry Editor" as an administrator and search for the copied "Application ID"

It should be something similar to this: HKEY_LOCAL_MACHINE\SOFTWARE\Classes\AppID\{A2EFA5CB-3B0E-11D2-9EFD-006097D2D7CF}

6. Right click on the Registry Key and select "Permissions..." from the pop-up menu

7. Go to "Advanced" button

8. Select "Owner" tab and change owner to "Administrator" - click the "Apply" button to save the changes.

9. Click "OK" to close the dialog

10. Now select the "Administrators" from the list of "Groups or User Names"

11. Give "Administrators" Full Control in the “Permissions for the Administrators” list and leave “TrustedInstaller” with Full Control as well.

12. Click “OK” to close the dialog.

Now you should be able to use DCOM Config security tab.

All code samples are provided "AS IS" without warranty of any kind, either express or implied, including but not limited to the implied warranties of merchantability and/or fitness for a particular purpose.

Why does the NdrClientCall2() API call takes more then 4-5 milliseconds to complete in my application? In rare cases I even see hundreds of milliseconds (57 millisecond at one time) just for the NdrClientCall2() API call to complete.

In my application no server side processing is involved. My client and server both are running on the same machine. In either case it is a ncacn_np operation, both sides are already connected, all the calls should complete with the same (or about same) delays.

Is it possible to explain what kinds of things might be involved in this delay?

Answer:

For local RPC calls, it is highly recommend that users to use ncalrpc and not ncacn_np. Ncacn_np is primarily for backwards compatibility and new applications should be using ncacn_ip_tcp for remote traffic. If you are using Vista or later, it is recommended to switch to the lower latency fast binding handle path for LRPC. This removes some significant sources of lock contention in the client path, potentially leading to a reduction in delays.

Please check the links below to know more about the fast RPC binding handle.

RpcBindingCreate
https://msdn.microsoft.com/en-us/library/aa375587(VS.85).aspx

RpcBindingBind
https://msdn.microsoft.com/en-us/library/aa375583(VS.85).aspx

RpcBindingUnbind
https://msdn.microsoft.com/en-us/library/aa375613(VS.85).aspx

RpcBindingFree
https://msdn.microsoft.com/en-us/library/aa375588(VS.85).aspx

On the other hand, the occasional delay is not all that odd. A DPC firing, while the test is executing, can easily cause a 3-4ms delay.

Also please remember, Windows is not a real time operating system and there is no way to give any upper bound guarantee for NdrClientCall2() API call.

We are trying to introduce QoS into our VOIP services. While working on this we have observed that TCP three way handshake never tag with DSCP value. We have reproduced the issue both in Windows XP and Windows Server 2003 operating systems. My question is why TCP three way handshake never tag with DSCP value? I don’t think this is an expected behavior, RFC 2474 mentioned nothing about this.

Answer:

On Windows XP and Server 2003, QoS DSCP tagging is applied when a data packet is being sent; depending on the DSCP value supplied by the application or the system-wide setting. During the TCP Handshake, since no data is being sent, DSCP marking is not done. This is an issue in the QoS stack of Windows XP and Server 2003.

Please note: This issue is fixed in Windows Vista and Windows 7.

On Windows XP, I am starting regedit.exe in suspended mode and forcing it to call the LoadLibrary() API to load an external DLL by using the CreateRemoteThread API. After loading the DLL, when I try to resume the suspended thread, the application terminates. Is this a known issue?

Answer:

Creating a remote thread into another process is a poor way to build extensibility into an application. Extendable applications should have some form of an API, a scripting language, plug-in DLL support, etc.

Regedit.exe was not meant to be extended by any means—it has no API and no plug-in interface and therefore does not expect to run any code or threads which are not built into it. Therefore, it also is not designed to run properly when another process calls the CreateRemoteThread to start a new thread within it. It may run or it may not. If it runs without a problem, it is only by coincidence.

In fact, Microsoft strongly discourages using CreateRemoteThread/CreateRemoteThreadEx to start a thread in any process. Its original purpose is to write debuggers and profilers. Even with these tools, creating a thread in another process has a risk that the target process can fail. Although the APIs themselves are documented and they will create a thread in another process (as documented), the effects the new thread has on the target process completely depend on what the target process and the new thread do – how they interact. It’s the latter that causes the all the problems.

When you create a new thread in a process that doesn’t expect it, there are many interactions which can occur. Here are some things that can happen:

a. The new thread requires a stack in the application’s address space. The application may want that memory for something else. Perhaps the application will fail to make an allocation and then crash because it can’t recover from something that should “never” happen.

b. It causes all the DllMain() functions of all the DLLs to get called for DLL_THREAD_ATTACH. One of these could call an API which shouldn’t be called from DllMain(), causing a deadlock.

c. It causes an extra DLL to get loaded somewhere in the process’s address space. It could be that the DLL is loaded into a place where the app wants to allocate memory. The DLL may load at its preferred address space or it may not—it depends on what is already in the process’s memory.

d. The application may use the single-threaded CRT (C runtime library) which now could have multiple threads calling it. Since the single-threaded CRT doesn’t set up the necessary data structures and locks to handle multiple threads, the CRT can crash.

e. The injected code could simply have a bug and cause the application to crash.

f. The thread could cause a deadlock if it uses any synchronization objects that other parts of the application use.

g. Anti-malware and anti-virus programs may get triggered and kill the target process, especially if it is a known administrative tool that should be prevented from being hacked.

Microsoft’s efforts to make the platform more secure means we invest in technologies like DEP (data execution prevention) which happen to do more than simply prevent someone from executing data. DEP also prevent exception handlers from executing in dynamically allocated code (because malware uses this technique), they may mark portions of the address space as no-access so that a DLL can’t be injected, address space layout randomization, required executable signing for kernel-mode modules, etc. Microsoft will continue to improve the security of its products by similar technical means, so there is a greater chance in the future these techniques such as creating remote threads will fail more frequently. (At the same time, a provision is made to allow debuggers to do what they need to do to be useful.)