mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
448 lines
14 KiB
448 lines
14 KiB
/* (C) Copyright Microsoft Corporation 1991. All Rights Reserved */
|
|
/* wavedisp.c
|
|
*
|
|
* Implements waveform display control ("td_wavedisplay").
|
|
*
|
|
* This is NOT a general-purpose control (see the globals below).
|
|
*
|
|
* The waveform is represented as a string of characters in a font that
|
|
* consists of vertical lines that correspond to different amplitudes.
|
|
* Actually there is no font, it's just done with patBlts
|
|
*
|
|
* WARNING: this control cheats: it stores information in globals, so you
|
|
* couldn't put it in a DLL (or use two of them in the same app)
|
|
* without changing it.
|
|
*/
|
|
/* Revision History.
|
|
* 4/2/92 LaurieGr (AKA LKG) Ported to WIN32 / WIN16 common code
|
|
* 25/6/92LaurieGr enhanced, Also had to reformat to 80 cols because
|
|
* NT has only crappy fonts again.
|
|
* 21/Feb/94 LaurieGr merged Daytona and Motown versions
|
|
*/
|
|
|
|
#include "nocrap.h"
|
|
#include <windows.h>
|
|
#include <windowsx.h>
|
|
#include <mmsystem.h>
|
|
#include <mmreg.h>
|
|
#include <math.h>
|
|
#include "SoundRec.h"
|
|
|
|
/* constants */
|
|
#define MAX_TRIGGER_SEARCH 200 // limit search for trigger pt.
|
|
#define MIN_TRIGGER_SAMPLE (128 - 8) // look for silent part
|
|
#define MAX_TRIGGER_SAMPLE (128 + 8) // look for silent part
|
|
|
|
#define MIN_TRIG16_SAMPLE (-1024) // look for silent part
|
|
#define MAX_TRIG16_SAMPLE (1024) // look for silent part
|
|
|
|
|
|
/* globals */
|
|
static NPBYTE gpbWaveDisplay; // text string in WaveLine font
|
|
// initially has samples in it
|
|
// enough room for 4 bytes/sample
|
|
static RECT grcWaveDisplay; // wave display rectangle
|
|
static HBITMAP ghbmWaveDisplay; // mono bitmap.
|
|
static HDC ghdcWaveDisplay; // memory DC for bitmap.
|
|
// static iXScale = 1; // samples per pel across screen
|
|
|
|
/* UpdateWaveDisplayString()
|
|
*
|
|
* Copy samples from just before the current position in the sample buffer
|
|
* to the wave display string. The code tries to find a good "trigger point"
|
|
* in the waveform so that the waveform will be aligned at the beginning of
|
|
* a wave.
|
|
*
|
|
* The current position is in gpWaveSamples at glWavePosition which is
|
|
* measured in samples (not bytes).
|
|
*
|
|
* The wave display string will contain numbers in the range -16..15
|
|
*
|
|
* for 8 bit: x' = abs(x-128)/8
|
|
* for 16 bit: x' = abs(x)/2048
|
|
*
|
|
* When the display is "in motion" (i.e. actually playing or recording
|
|
* we try to keep the display somewhat static by looking for a trigger
|
|
* point (like an oscilloscope would) and display that part of the wave
|
|
* that has just either played or been recorded.
|
|
*
|
|
*/
|
|
static void NEAR PASCAL
|
|
UpdateWaveDisplayString(void)
|
|
{
|
|
|
|
// piSrc and pbSrc are init NULL to kill a compiler diagnostic.
|
|
// The compiler cannot follow the logic and thinks that they may be
|
|
// used before being set. (It's wrong. Hint: look at cbSrc and cbTrigger)
|
|
|
|
BYTE * pbSrc = NULL; // pointer into <gpWaveSamples> to 8 bits
|
|
short * piSrc = NULL; // pointer into <gpWaveSamples> to 16 bits
|
|
// (use one or other according to wave format)
|
|
|
|
int cbSrc; // number of samples that can be copied
|
|
BYTE * pbDst; // pointer into <gpbWaveDisplay>
|
|
int cbDst; // size of <gpWaveDisplay>
|
|
int cbTrigger; // limit the search for a "trigger"
|
|
BYTE b;
|
|
int i;
|
|
int cnt;
|
|
|
|
WORD nSkipChannels;
|
|
BOOL fStereoIn;
|
|
BOOL fEightIn;
|
|
|
|
cbDst = grcWaveDisplay.right - grcWaveDisplay.left; // rectangle size
|
|
pbDst = gpbWaveDisplay;
|
|
|
|
// Note: IsWaveFormatPCM() is called before this function is ever called, therefore
|
|
// we can always rely on the fact that gpWaveFormat->wwFormatTag == WAVE_FORMAT_PCM.
|
|
// This also implies, as mentioned in the docs on WAVEFORMATEX, that the
|
|
// gpWaveFormat->wBitsPerSample should be equal to 8 or 16.
|
|
|
|
// Note: We average the first two channels if they exist, any additional channels are
|
|
// ignored.
|
|
|
|
fStereoIn = gpWaveFormat->nChannels != 1;
|
|
fEightIn = ((LPWAVEFORMATEX)gpWaveFormat)->wBitsPerSample == 8;
|
|
nSkipChannels = max (0, gpWaveFormat->nChannels - 2);
|
|
|
|
/* search for a "trigger point" if we are recording or playing */
|
|
if ((ghWaveOut != NULL) || (ghWaveIn != NULL))
|
|
{ // we are in motion - align the *right* hand side of the window.
|
|
cbTrigger = MAX_TRIGGER_SEARCH;
|
|
|
|
if (gpWaveSamples == NULL)
|
|
{
|
|
/* no document at all is open */
|
|
cbSrc = 0;
|
|
}
|
|
else
|
|
{
|
|
long lStartOffsetSrc, lEndOffsetSrc;
|
|
|
|
/* align the *right* side of wave display to the current
|
|
* position in the wave buffer, so that during recording
|
|
* we see only samples that have just been recorded
|
|
*/
|
|
lStartOffsetSrc = glWavePosition - (cbDst + cbTrigger);
|
|
lEndOffsetSrc = glWavePosition;
|
|
if (lStartOffsetSrc < 0)
|
|
lEndOffsetSrc -= lStartOffsetSrc, lStartOffsetSrc = 0L;
|
|
if (lEndOffsetSrc > glWaveSamplesValid)
|
|
lEndOffsetSrc = glWaveSamplesValid;
|
|
|
|
// Bombay Bug 1360: lStartOffsetSrc > lEndOffsetSrc causes GP Fault
|
|
// if glWaveSamplesValid < lStartOffsetSrc we have a problem.
|
|
|
|
if (lStartOffsetSrc > lEndOffsetSrc)
|
|
{
|
|
lStartOffsetSrc = lEndOffsetSrc - (cbDst + cbTrigger);
|
|
if (lStartOffsetSrc < 0)
|
|
lStartOffsetSrc = 0L;
|
|
}
|
|
|
|
cbSrc = (int)wfSamplesToBytes(gpWaveFormat, lEndOffsetSrc - lStartOffsetSrc);
|
|
|
|
/* copy samples from buffer into local one */
|
|
memmove( gpbWaveDisplay
|
|
, gpWaveSamples + wfSamplesToBytes(gpWaveFormat, lStartOffsetSrc)
|
|
, cbSrc
|
|
);
|
|
|
|
pbSrc = (BYTE *) gpbWaveDisplay;
|
|
piSrc = (short *) gpbWaveDisplay;
|
|
}
|
|
|
|
if (cbTrigger > 0) {
|
|
cbTrigger = min(cbSrc, cbTrigger); // don't look beyond buffer end
|
|
|
|
/* search for a silent part in waveform */
|
|
if (fEightIn)
|
|
{
|
|
while (cbTrigger > 0)
|
|
{
|
|
b = *pbSrc;
|
|
if ((b > MIN_TRIGGER_SAMPLE) && (b < MAX_TRIGGER_SAMPLE))
|
|
break;
|
|
cbSrc--, pbSrc++, cbTrigger--;
|
|
if (fStereoIn)
|
|
pbSrc+=(nSkipChannels+1);
|
|
}
|
|
}
|
|
else
|
|
{ // not EightIn
|
|
while (cbTrigger > 0)
|
|
{
|
|
i = *piSrc;
|
|
if ((i > MIN_TRIG16_SAMPLE) && (i < MAX_TRIG16_SAMPLE))
|
|
break;
|
|
cbSrc--, piSrc++, cbTrigger--;
|
|
if (fStereoIn)
|
|
piSrc+=(nSkipChannels+1);
|
|
}
|
|
}
|
|
|
|
/* search for a non-silent part in waveform (this is the "trigger") */
|
|
if (fEightIn)
|
|
{
|
|
while (cbTrigger > 0)
|
|
{
|
|
b = *pbSrc;
|
|
if ((b <= MIN_TRIGGER_SAMPLE) || (b >= MAX_TRIGGER_SAMPLE))
|
|
break;
|
|
cbSrc--, pbSrc++, cbTrigger--;
|
|
if (fStereoIn)
|
|
pbSrc+=(nSkipChannels+1);
|
|
}
|
|
}
|
|
else
|
|
{ // not EightIn
|
|
while (cbTrigger > 0)
|
|
{
|
|
i = *piSrc;
|
|
if ((i <= MIN_TRIG16_SAMPLE) || (i >= MAX_TRIG16_SAMPLE))
|
|
break;
|
|
cbSrc--, piSrc++, cbTrigger--;
|
|
if (fStereoIn)
|
|
piSrc+=(nSkipChannels+1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else // it's not playing or recording - static display
|
|
{
|
|
long lStartOffsetSrc, lEndOffsetSrc;
|
|
|
|
/* align the *left* side of wave display to the current
|
|
* position in the wave buffer
|
|
*/
|
|
lStartOffsetSrc = glWavePosition;
|
|
lEndOffsetSrc = glWavePosition + cbDst;
|
|
if (lEndOffsetSrc > glWaveSamplesValid)
|
|
lEndOffsetSrc = glWaveSamplesValid;
|
|
|
|
cbSrc = (int)wfSamplesToBytes( gpWaveFormat
|
|
, lEndOffsetSrc - lStartOffsetSrc
|
|
);
|
|
|
|
//
|
|
// copy samples from buffer into local one
|
|
//
|
|
memmove( gpbWaveDisplay
|
|
, gpWaveSamples
|
|
+ wfSamplesToBytes(gpWaveFormat, lStartOffsetSrc)
|
|
, cbSrc
|
|
);
|
|
|
|
pbSrc = (BYTE *) gpbWaveDisplay;
|
|
piSrc = (short *) gpbWaveDisplay;
|
|
}
|
|
|
|
cnt = min(cbSrc, cbDst);
|
|
cbDst -= cnt;
|
|
|
|
/* map cnt number of samples from pbSrc to string characters at pbDst
|
|
** fEightIn => 8 byte samples, else 16
|
|
** fStereoIn => Average left and right channels
|
|
**
|
|
** pbSrc and pbDst both point into the same buffer addressed by
|
|
** gpbWaveDisplay, pbSrc >= pbDst. We process left to right, so OK.
|
|
*/
|
|
|
|
if (fEightIn)
|
|
{
|
|
BYTE *pbDC = pbDst;
|
|
int dccnt = cnt;
|
|
DWORD dwSum = 0L;
|
|
|
|
while (cnt-- > 0)
|
|
{
|
|
b = *pbSrc++;
|
|
if (fStereoIn)
|
|
{
|
|
// Average left and right channels.
|
|
b /= 2;
|
|
b += (*pbSrc++ / 2);
|
|
// Skip channels past Stereo
|
|
pbSrc+=nSkipChannels;
|
|
}
|
|
dwSum += *pbDst++ = (BYTE)(b/8 + 112); // 128 + (b-128)/8
|
|
}
|
|
|
|
/* Eliminate DC offsets by subtracting the average offset
|
|
* over all samples.
|
|
*/
|
|
if (dwSum)
|
|
{
|
|
dwSum /= (DWORD)dccnt;
|
|
dwSum -= 128;
|
|
while (dwSum && dccnt-- > 0)
|
|
*pbDC++ -= (BYTE)dwSum;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
BYTE *pbDC = pbDst;
|
|
int dccnt = cnt;
|
|
LONG lSum = 0L;
|
|
|
|
while (cnt-- > 0)
|
|
{
|
|
i = *piSrc++;
|
|
if (fStereoIn)
|
|
{
|
|
// Average left and right channels.
|
|
i /= 2;
|
|
i += (*piSrc++ / 2);
|
|
// Skip channels past Stereo
|
|
piSrc+=nSkipChannels;
|
|
}
|
|
lSum += *pbDst++ = (BYTE)(i/2048 + 128);
|
|
}
|
|
|
|
/* Eliminate DC offsets by subtracting the average offset
|
|
* over all samples.
|
|
*/
|
|
if (lSum)
|
|
{
|
|
lSum /= dccnt;
|
|
lSum -= 128;
|
|
while (lSum && dccnt-- > 0)
|
|
*pbDC++ -= (BYTE)lSum;
|
|
}
|
|
|
|
}
|
|
/* if necessary, pad the strings with whatever character represents
|
|
* the "silence level". This is 128, the midpoint level.
|
|
*/
|
|
while (cbDst-- > 0)
|
|
*pbDst++ = 128;
|
|
}
|
|
|
|
/* WaveDisplayWndProc()
|
|
*
|
|
* This is the window procedure for the "WaveDisplay" control.
|
|
*/
|
|
INT_PTR CALLBACK
|
|
WaveDisplayWndProc(HWND hwnd, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
PAINTSTRUCT ps;
|
|
RECT rc;
|
|
int i;
|
|
int n;
|
|
int dx;
|
|
int dy;
|
|
|
|
switch (wMsg)
|
|
{
|
|
case WM_CREATE:
|
|
/* make the window a bit bigger so that it lines up with
|
|
* the frames of the shadow-frames beside it
|
|
*/
|
|
|
|
/* allocate <gpbWaveDisplay> */
|
|
GetClientRect(hwnd, &grcWaveDisplay);
|
|
InflateRect(&grcWaveDisplay, -1, -1); // account for border
|
|
|
|
gpbWaveDisplay = (NPBYTE)GlobalAllocPtr(GHND,
|
|
(grcWaveDisplay.right+MAX_TRIGGER_SEARCH) * 4);
|
|
// 4 is the maximum bytes per sample allowed
|
|
|
|
if (gpbWaveDisplay == NULL)
|
|
return -1; // out of memory
|
|
|
|
ghdcWaveDisplay = CreateCompatibleDC(NULL);
|
|
|
|
if (ghdcWaveDisplay == NULL)
|
|
return -1; // out of memory
|
|
|
|
ghbmWaveDisplay = CreateBitmap(
|
|
grcWaveDisplay.right-grcWaveDisplay.left,
|
|
grcWaveDisplay.bottom-grcWaveDisplay.top,
|
|
1,1,NULL);
|
|
|
|
if (ghbmWaveDisplay == NULL)
|
|
return -1; // out of memory
|
|
|
|
SelectObject(ghdcWaveDisplay, ghbmWaveDisplay);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
/* free <gpbWaveDisplay> */
|
|
if (gpbWaveDisplay != NULL)
|
|
{
|
|
GlobalFreePtr(gpbWaveDisplay);
|
|
gpbWaveDisplay = NULL;
|
|
}
|
|
|
|
if (ghbmWaveDisplay != NULL)
|
|
{
|
|
DeleteDC(ghdcWaveDisplay);
|
|
DeleteObject(ghbmWaveDisplay);
|
|
ghdcWaveDisplay = NULL;
|
|
ghbmWaveDisplay = NULL;
|
|
}
|
|
|
|
break;
|
|
|
|
case WM_ERASEBKGND:
|
|
/* draw the border and fill */
|
|
GetClientRect(hwnd, &rc);
|
|
DrawShadowFrame((HDC)wParam, &rc);
|
|
return 0L;
|
|
|
|
case WM_PAINT:
|
|
BeginPaint(hwnd, &ps);
|
|
|
|
if (!IsWaveFormatPCM(gpWaveFormat))
|
|
{
|
|
FillRect(ps.hdc, &grcWaveDisplay, ghbrPanel);
|
|
}
|
|
else if (gpbWaveDisplay != NULL)
|
|
{
|
|
/* update <gpbWaveDisplay> */
|
|
UpdateWaveDisplayString();
|
|
|
|
dx = grcWaveDisplay.right-grcWaveDisplay.left;
|
|
dy = grcWaveDisplay.bottom-grcWaveDisplay.top;
|
|
|
|
//
|
|
// update the bitmap.
|
|
//
|
|
PatBlt(ghdcWaveDisplay,0,0,dx,dy,BLACKNESS);
|
|
PatBlt(ghdcWaveDisplay,0,dy/2,dx,1,WHITENESS);
|
|
|
|
for (i=0; i<dx; i++)
|
|
{
|
|
n = (BYTE)gpbWaveDisplay[i]; // n.b. must get it UNSIGNED
|
|
n = n-128; // -16..15
|
|
|
|
if (n > 0)
|
|
PatBlt(ghdcWaveDisplay,
|
|
i, dy/2-n,
|
|
1, n*2+1, WHITENESS);
|
|
|
|
if (n < -1)
|
|
{
|
|
n++; // neg peak == pos peak
|
|
PatBlt(ghdcWaveDisplay,
|
|
i, dy/2+n,
|
|
1, -(n*2)+1, WHITENESS);
|
|
}
|
|
}
|
|
|
|
/* draw the waveform */
|
|
SetTextColor(ps.hdc, RGB_BGWAVEDISP);
|
|
SetBkColor(ps.hdc, RGB_FGWAVEDISP);
|
|
|
|
BitBlt(ps.hdc, grcWaveDisplay.left, grcWaveDisplay.top,
|
|
dx,dy, ghdcWaveDisplay, 0, 0, SRCCOPY);
|
|
}
|
|
|
|
EndPaint(hwnd, &ps);
|
|
return 0L;
|
|
}
|
|
|
|
return DefWindowProc(hwnd, wMsg, wParam, lParam);
|
|
}
|