Correct WAVE_FORMAT_1S16 PCM dual-channel format? - audio

Question

I am trying to play 2 16-bit PCM streams on Windows 10 WinMM Audio,
each on a separate channel, using this WAVEFORMATEX :
const WAVEFORMATEX
_wex_ = // (WAVEFORMATEX)
{ .wFormatTag = WAVE_FORMAT_PCM
, .nChannels = 2
, .nSamplesPerSec = 8000
, .nAvgBytesPerSec= 16000
, .nBlockAlign = 4
, .wBitsPerSample = 16
, .cbSize = 0
};
When I play them with 2 processes, process A laying out its stream like:
Bit 31: | :Bit 0
<PCM_16_BITS> | 00 ... 00
and process B laying out its stream like:
Bit 31: | :Bit 0
00 ... 00 | <PCM_16_BITS>
, then the stream plays on left and right channels successfully (is Mixed
by the WAS Mixer device - each stream plays on only one channel so is played only
on left or right speaker ).
But if I write a single process which combines the two streams, so that
a single stream is laid out like:
Bit 31: | :Bit 0
<LEFT PCM_16_BITS> | <RIGHT PCM_16_BITS>
then the stream plays as garbled nonsense.
Please could anyone enlighten me as to the actual byte layout that Windows Audio
expects the frames to have for 2-channel 16-bit PCM as configured by my WAVEFORMATEX ?
I have written the code to invoke waveOutOpen, waveOutPrepareHeader, and waveOutWrite, etc., which works fine, it is just when I try to
play a combined stream with the 2 left|right 16-bit audio samples laid out in
high 16 bits and low 16 bits of 32-bit words that the output is garbled -
I guess I just do not know what format Windows Audio is expecting here.
Or is my WAVEFORMATEX in error somehow?
Or point to where this might be documented ? The Microsoft docs go into excruciating detail on header file contents without actually explaining things like stream layouts at all.
Thanks in advance for any helpful advice / replies.

Answer 1

Aha! I finally found :
https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ksmedia/ns-ksmedia-waveformatextensible
and
https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/ksmedia/ns-ksmedia-ksaudio_channel_config
which do answer the question - I guess if I am sending 2 channels
in one frame I have to use 12 bytes per channel .

Answer 2

OK, the last answer wasn't really an answer - here is a better attempt -
To save anyone else the headaches I have been through the last few days,
here is the corrected 'pwfx' waveOutOpen parameter:
const WAVEFORMATEXTENSIBLE
_wex_ext_ =
{ .Format =
{ .wFormatTag = WAVE_FORMAT_EXTENSIBLE
, .nChannels = 2
, .nSamplesPerSec = 8000
, .nAvgBytesPerSec= 32000
, .nBlockAlign = 4
, .wBitsPerSample = 16
, .cbSize = sizeof(WAVEFORMATEXTENSIBLE) -
sizeof(WAVEFORMATEX)
}
, .Samples = {16}
, .dwChannelMask = (SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT)
, .SubFormat = DEFINE_WAVEFORMATEX_GUID(WAVE_FORMAT_PCM)
};
So if that is used as the structure to which 'pwfx' points :
switch
( r =
waveOutOpen
( &aoh // Audio Output Handle
, WAVE_MAPPER
, ((WAVEFORMATEX*)&_wex_ext_)
, ((DWORD_PTR)waveOutProc) // Callback function on WOM_DONE
, ((DWORD_PTR)0UL) // no user paramet
, WAVE_FORMAT_DIRECT | CALLBACK_FUNCTION // do not modify audio data
)
)
{case MMSYSERR_NOERROR:
break;
case MMSYSERR_ALLOCATED:
ok = false;
emsg = "Specified resource is already allocated.";
break;
case MMSYSERR_BADDEVICEID:
ok = false;
emsg = "Specified device identifier is out of range.";
break;
case MMSYSERR_NODRIVER:
ok = false;
emsg = "No device driver is present.";
break;
case MMSYSERR_NOMEM:
ok = false;
emsg = "Unable to allocate or lock memory.";
break;
case WAVERR_BADFORMAT:
ok = false;
emsg = "Attempted to open with an unsupported waveform-audio format.";
break;
case WAVERR_SYNC:
ok = false;
emsg = "The device is synchronous but waveOutOpen was called without using the WAVE_ALLOWSYNC flag.";
break;
default:
ok = false;
if ( 0 == waveOutGetErrorText(r, ((u8_t*) &pcm[0].l[0]), 1024 ))
{ u16_t len = 1024;
s8_t *str = ((s8_t*)&pcm[0].l[0]);
utf8str( ((u16_t*)&pcm[0].l[0]), wcslen((U16_t*)&pcm[0].l[0]), &str, &len);
emsg = ((const char*) &pcm[0].l[0]);
}
break;
}
Then either of the two SINGLE CHANNEL formats played by 2 processes:
Bit:15
Bit: 31: | Bit: 0:
<16-bit LE PCM L>| 0 ... 0 # all zeros, OR:
Bit:15
Bit: 31: | Bit: 0:
0 ... 0| <16-bit LE PCM R> |
works fine, and mixes so that "PCM L" plays on LEFT channel, and PCM R
plays on RIGHT channel,
But I have had no NO success playing this with a single process :
Bit:15
Bit: 31: | Bit: 0:
<1| <16-bit LE PCM L> | <16-bit LE PCM R>
The same occurs when playing the stream with ALSA (alsa-lib) on Linux -
so it is not a windows thing.
On Linux, with ALSA's S16_LE format,
I have tried playing the same streams, in one process, like:
Bit:15
Bit: 31: | Bit: 0:
<16-bit LE PCM L>| 0 ... 0 # all zeros
0 ... 0| <16-bit LE PCM R>
I have also tried:
Bit:15
Bit: 31: | Bit: 0:
0 ... 0| <16-bit LE PCM L>|
0 ... 0| <16-bit LE PCM R>|
and:
Bit:15
Bit: 31: | Bit: 0:
<16-bit LE PCM L>| 0 ... 0|
<16-bit LE PCM R>| 0 ... 0|
But these also donot work (the stream is full of clicks & glitches
and the signals seem to alternate between Left & Right & are barely
audible). Of course, how could that work if I've specified the
S16_LE format, which expects 16-bit frames , and I'm writing 32-bit
frames ?
So, I'm really stuck as to what the exact interleaving byte format
should be.
On Windows, the code doing the interleaving looks like:
typedef struct pcm_frame_s
{ U16_t l[320], r[320], lr[640];
} PCMFrame_t;
static
PCMFrame_t pcm[16] = {0};
...
// pcmA & pcmB are pointers to pcm[i].l[0] & pcm[i].r[0] :
if ( pcmA && pcmB )
{ register U8_t
np;
register U16_t
*ppcm =&pcm[i].lr[0];
for( np = 0
, pcmA=&pcm[i].l[0]
, pcmB=&pcm[i].r[0]
; np < 160
; ++np, ++ppcm, ++pcmA, ++pcmB
)
{ *ppcm = *pcmA ? *pcmA : pcm_slnc[np];
ppcm += 1;
*ppcm = *pcmB ? *pcmB : pcm_slnc[np];
} // pcm_slnc is a pre-computed "Comfort Noise" block
}else
{ register U8_t
np;
register U16_t
*ppcm = &pcm[i].lr[0]
, *pspcm = pcmA ? pcmA : pcmB;
if(left) // user has chosen to put 1st stream on left channel
{
for(np=0; np < 160; ++np, ++ppcm, ++pspcm)
{ *ppcm = *pspcm;
ppcm += 1;
*ppcm = pcm_slnc[np];
}
} else
{
for(np=0; np < 160; ++np, ++ppcm, ++pspcm)
{ *ppcm = pcm_slnc[np];
ppcm += 1;
*ppcm=*pspcm;
}
}
}
while ( (WHDR_PREPARED | WHDR_DONE)
!= (wh[i].dwFlags & (WHDR_PREPARED | WHDR_DONE))
)
{ if (!WaitOnAddress
( &(wh[i].dwFlags)
, &playingDwFlags
, sizeof(u32_t)
, INFINITE
)
)
{ say(FMT("WaitOnAddress failed in INFINITE mode."));
ok = false;
break;
}
}
wh[i].dwFlags &= ~WHDR_DONE;
switch
( r = waveOutWrite(aoh, &wh[i], sizeof(wh[i])) )
{case MMSYSERR_NOERROR:
...
I think I MUST specify 32-bits per channel, and use a 32-bit frame size?
So there is no way I can interleave two 16-bit left | right channel
PCM values next to each other without using a 32-bit stream format ?
I am on the verge of giving up and just using 2 processes and the
mixer, which strangely DOES honor the "<left 16 bits>|0" (left process) and
"0|<right 16-bits>" (right process) (left | right) channel format
and send them to the left / right speakers as expected.
But there is no way to specify two 16-bit channels in a 32-bit word?
Strange.