#include "wutils.h"
#include "quelle.h"
#include <math.h>
#include <stdlib.h> //random
#include <stdio.h> //sscanf
// Globales
extern HWND MainWnd;
extern TCHAR HelpFileName[];
extern TCHAR StdProfile[];
extern WAVEHDR WaveHdr;
extern QUELLE* quelle;
extern void Float2String(PTSTR s, float v, WORD minmax, PCTSTR Einheit,int precis=3);
extern bool String2Float(PCTSTR s, float&z, PTSTR e);
#define ELEN 8
SOFT_TRIGGER st; // Globale Variable
/*********************************************************
** Die folgenden Triggersuchroutinen dürfen nie **
** mit <len>=0 oder ungültigem <buf> gerufen werden! **
** <len> und Rückgabewert sind stets in Bytes gemeint. **
*********************************************************/
// Eigentlich wäre hier auch die Erkennung von Übersteuerung praktisch...
// DC-Präprozessor für nicht zu triggernde Daten
void NEAR DcProcess(LPSTR buf,UINT len) {
len-=st.blockalign;
buf+=st.blockadd+len;
st.y=st.getsample(buf,st.mask); // Letztes Sample setzen
};
// DC-Hauptprozessor für zu triggernde Daten
UINT NEAR DcTrigger(LPSTR buf, UINT len) {
int cmp,xor;
LPSTR p=buf+st.blockadd;
xor=st.xor; // <xor> =0: steigend, =-1: fallend (=Negation)
cmp=st.cmp1^xor; // <cmp1> muss bei FALLEND größer als <cmp2> sein!
// <y> enthält den NICHT-NEGIERTEN alten Wert
// <y> sollte mit MAXINT~xor initialisiert werden
if ((st.y^xor)<=cmp) {xor=~xor; cmp=st.cmp2^xor;}// Zweiten Vergleich laden
do{
st.y=st.getsample(p,st.mask);
if ((st.y^xor)<=cmp) {
if (xor!=st.xor) break; // Flanke gefunden
{xor=~xor; cmp=st.cmp2^xor;} // Zweiten Vergleich laden
}
p+=st.blockalign;
}while (len-=st.blockalign);
return (UINT)(p-st.blockadd-buf);
}
// AC-Präprozessor: Gleichspannungspegel mitführen
void NEAR AcProcess(LPSTR buf, UINT len) {
buf+=st.blockadd;
len/=st.blockalign;
do{
st.y=st.getsample(buf,st.mask);
st.makesub();
buf+=st.blockalign;
}while (--len);
}
// AC-Hauptprozessor: Wie DcTrigger + AcProcess
// Auch geeignet für TVH, TVL, mit entsprechendem "makesub"
UINT NEAR AcTrigger(LPSTR buf, UINT len) {
int cmp,xor;
LPSTR p=buf+st.blockadd;
len/=st.blockalign;
xor=st.xor; // <xor> =0: steigend, =-1: fallend (=Negation)
cmp=st.cmp1^xor; // <cmp1> muss bei FALLEND größer als <cmp2> sein!
// <y> enthält den NICHT-NEGIERTEN alten Wert
// <y> sollte mit MAXINT~xor initialisiert werden
if (((st.y-GET_SUB(st.sub))^xor)<=cmp) {
xor=~xor; cmp=st.cmp2^xor; // Zweiten Vergleich laden
}
do{
st.y=st.getsample(p,st.mask);
if (((st.y-GET_SUB(st.sub))^xor)<=cmp) {
if (xor!=st.xor) break; // Flanke gefunden
{xor=~xor; cmp=st.cmp2^xor;} // Zweiten Vergleich laden
}
st.makesub();
p+=st.blockalign;
}while (--len);
return (UINT)(p-st.blockadd-buf);
}
UINT NEAR ExtTrigger(LPSTR, UINT) {return 0;} // sofort triggern lassen
/* die Monsterroutine */
bool FindTrigger(/*GETPROC getproc,NPVOID getdata/*,UINT timeout*/) {
#define Flags (*(BYTE*)&WaveHdr.dwFlags)
#define pNext WaveHdr.lpNext
bool r=false;
if (Flags&WHDR_DONE) return r; // geht nicht!
UINT Len,LenA; // Entnahme-Bytes: Vorhanden, entnommen
LPSTR Start; // Entnahme-Start
if (pNext) {
// Len = Entnahme-Menge, Start = Entnahme-Adresse
Start=(LPSTR)pNext->dwUser; // der "Saug-Stand"
Len=(UINT)(pNext->lpData-Start)+(UINT)pNext->dwBytesRecorded; // Länge ergibt sich
if ((long)Len<0) DebugBreak(); // Notbremse
}
UINT tic=(UINT)GetTickCount();
#ifndef WIN32
LenA=0; // Compiler-Warning abstellen
#endif
for(;(UINT)GetTickCount()-tic<100; Start+=LenA, Len-=LenA){ // ... wird bei continue ausgeführt
// Platz = feier Speicher am Ziel
size_t Platz=WaveHdr.dwBufferLength-WaveHdr.dwBytesRecorded;
if (!pNext || !Len) {
// Wenn kein Puffer vorhanden, oder Puffer leer gesaugt...
quelle->RelayMsg(Q_POLL,&WaveHdr);
// getproc(getdata,&pNext);
if (!pNext) break; // keine weiteren Daten
Flags=(BYTE)((Flags&~WHDR_PREPARED)|(pNext->dwFlags&WHDR_PREPARED));
Start=pNext->lpData;
Len=(UINT)pNext->dwBytesRecorded;
if (!Len) { // Leerer Block markiert Speicherende
Flags|=WHDR_DONE;
break;
}
}
LenA=Len;
if (Flags&WHDR_ENDLOOP) { // Trigger bereits gefunden?
{DWORD weg=-(long)WaveHdr.reserved;
if ((long)weg>0) { // Samples vernichten?
if (LenA>weg) LenA=(UINT)weg;
WaveHdr.reserved+=LenA; // negativen Trigger vorrücken
continue;
}
} // sonst: Samples kopieren
if (!Platz) break; // Puffer voll! Kein Wrap-Around!
kopieren:
if (LenA>Platz) LenA=(UINT)Platz; // Minimum
st.praeproc(Start,LenA);
CopyMemory((char huge*)WaveHdr.lpData+WaveHdr.dwBytesRecorded,Start,LenA);
r=true;
WaveHdr.dwBytesRecorded+=LenA; // DWORD-Inkrement
if (WaveHdr.dwUser<WaveHdr.dwBytesRecorded) // alte Daten verschwunden?
WaveHdr.dwUser=WaveHdr.dwBytesRecorded; // OldData-Index vorschieben
continue;
} // sonst: Prä-Trigger-Daten aufsammeln
if (!(Flags&WHDR_BEGINLOOP)) {
Platz=WaveHdr.reserved-WaveHdr.dwBytesRecorded; // Bereich A
if ((long)Platz>0) goto kopieren;
Flags|=WHDR_BEGINLOOP;
WaveHdr.dwLoops=0;
} // sonst: Trigger suchen
Platz=-(long)WaveHdr.reserved;
if ((long)Platz<0) Platz=0;
Platz+=WaveHdr.dwBufferLength; // Maximale Triggersuch-Länge
if (LenA>Platz) LenA=(UINT)Platz;
UINT TrPos=st.trigproc(Start,LenA);
if (TrPos!=LenA) Flags|=WHDR_ENDLOOP; // Trigger gefunden
// Jetzt die Daten VOR dem Trigger verarbeiten
Platz=WaveHdr.reserved; // Prätrigger-Bereich
if ((long)Platz<0) Platz=0;
if (TrPos>Platz) { // einige Prätrigger-Daten vernichten:
LenA=TrPos-(UINT)Platz; // Was weggeworfen werden muss
Start+=LenA;
Len-=LenA;
TrPos-=LenA; // Jetzt ist TrPos <= Platz
}
// Daten in Bereich A (zwischen dwLoops und reserved)
Platz=WaveHdr.reserved-WaveHdr.dwLoops;
LenA=TrPos;
if (LenA>Platz) LenA=(UINT)Platz;
if (LenA) {
kop2:
CopyMemory((char huge*)WaveHdr.lpData+WaveHdr.dwLoops,Start,LenA);
r=true;
WaveHdr.dwLoops+=LenA;
TrPos-=LenA;
}
if (TrPos) { // ansonsten siehe Schleifenkopf
Start+=LenA; // Rest der Prätrigger-Daten in Bereich B
Len-=LenA; // (muss immer passen)
WaveHdr.dwLoops=0; // (zwischen Anfang und dwLoops)
LenA=TrPos;
goto kop2;
}
}
if (pNext) pNext->dwUser=(LPARAM)Start;
// wh->lpNext=pNext;
// wh->dwFlags=Flags;
return r;
#undef pNext
#undef Flags
}
int _fastcall GetCharSample(LPSTR p, BYTE xor) {// irgendwas, xor-zentriert
return (signed char)(*p^xor);
}
int _fastcall GetShortSample(LPSTR p, BYTE) { // 16-bit-Soundkarte
return (short)(*(LPWORD)p);
}
int _fastcall GetBitSample(LPSTR p, BYTE mask) {// Logikanalysator
return *p&mask?1:0;
}
static void _fastcall AcMakeSub(void) { // Soft-Trigger-Version
st.sub+=st.y-GET_SUB(st.sub);
}
/************************
** 0. Die Basisklasse **
************************/
bool QUELLE::RelayMsg(Q_MSG Msg,LPVOID lParam) {
switch (Msg) {
case Q_INIT: {
st.getsample=GetCharSample;
st.trigproc=DcTrigger;
st.praeproc=DcProcess;
st.makesub=AcMakeSub; // wird von DcTrigger, DcProcess nicht verwendet
st.mask=0; // für 0-zentrierte Daten
st.blockadd=0;
st.xor=0;
st.sub=0;
st.cmp1=0;
st.cmp2=1;
st.blockalign=2; // meistens!
st.pre=0;
st.min=-128;
st.max=127; // 8 bit, meistens
state=0;
sd.hDlg=0;
}return true;
case Q_SETUPDLG: {
#define di ((LPDLGINFO)lParam)
if (!di) return false;
if (sd.hDlg) {SetActiveWindow(sd.hDlg); return true; }
sd.kbHand=di->kbHand;
if (sd.kbHand) sd.hDlg=CreateDialogParam(HInstance,MAKEINTRESOURCE(sd.helpId),
di->parent,sd.dlgProc,(LPARAM)this);
else if (DialogBoxParam(HInstance,MAKEINTRESOURCE(sd.helpId),
di->parent,sd.dlgProc,(LPARAM)this)!=IDOK) return false;
#undef di
}return true;
case Q_DONE: {
if (state&Q_ARMED) RelayMsg(Q_UNARM,0); // idiotensicher!
if (sd.hDlg) DestroyWindow(sd.hDlg);
}break;
case Q_ARM: {
state|=Q_ARMED;
}break;
case Q_UNARM: {
state&=(BYTE)~Q_ARMED;
}break;
case Q_SETTRIG: { // wertet COUPLING, EDGE und LEVEL aus (für EDGE_TRIGGER)
#define t ((LPTRIG)lParam)
if (!t) return false;
if (t->what&TRIG_COUPLING) {
switch (t->coupling) {
case TRIG_DC: st.trigproc=DcTrigger; st.praeproc=DcProcess; break;
case TRIG_AC: st.trigproc=AcTrigger; st.praeproc=AcProcess; break;
default: return false;
}
trcoupling=t->coupling;
}
if (t->what&TRIG_EDGE) {
if (t->edge>=2) return false;
st.xor=t->edge?-1:0;
}
if (t->what&TRIG_LEVEL) {
st.cmp2=Limit(t->level,st.min,st.max);
}
st.cmp1=st.cmp2-1;
if (st.xor) st.cmp1+=2;
t->coupling=trcoupling;
t->edge=(BYTE)(st.xor&1);
t->level=st.cmp2;
#undef t
}return true;
case Q_POLL: {
if (!(state&Q_ARMED)) return false;
#define wh ((LPWAVEHDR)lParam)
if (!wh) return false;
if (wh->dwFlags&WHDR_INQUEUE) return true;
wh->dwFlags=WHDR_INQUEUE;
// wh->dwBytesRecorded=0;
// wh->dwUser=0;
// if (st.pre>(long)wh->dwBufferLength) st.pre=wh->dwBufferLength;
// wh->reserved=st.pre; // begrenzen!
// st.Reset();
#undef wh
}return true;
}
return false;
}
void DefDlgBottom(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam, SETUPDLG *sd) {
// "untere Hälfte" aller Dialoge behandelt OK und Abbrechen
// sowie Hilfe und das Aktivieren für moduslose Dialoge
switch (Msg) {
case WM_ACTIVATE: if (sd->kbHand) *sd->kbHand=wParam?Wnd:0; break;
case WM_COMMAND: switch (LOWORD(wParam)) {
case IDOK:
case IDCANCEL: {
if (sd->kbHand) DestroyWindow(Wnd); // Moduslos
else EndDialog(Wnd,LOWORD(wParam)); // Modal
}break;
case IDHELP: WinHelp(Wnd,HelpFileName,HELP_CONTEXT,sd->helpId);
}break;
#ifdef WIN32
case WM_HELP: {
DWORD a[4];
a[0]=((LPHELPINFO)lParam)->iCtrlId;
a[1]=MAKELONG(((LPHELPINFO)lParam)->iCtrlId,sd->helpId);
a[2]=0;
a[3]=0;
WinHelp((HWND)((LPHELPINFO)lParam)->hItemHandle,HelpFileName,HELP_WM_HELP,(DWORD)a);
}break;
case WM_CONTEXTMENU: {
WinHelp((HWND)wParam,HelpFileName,HELP_CONTEXTMENU,0);
}break;
#endif
case WM_DESTROY: sd->hDlg=0; break;
}
}
/*****************************************************
** 1. Eine 2kanalige Datenquelle für Zufallszahlen **
*****************************************************/
#ifndef __BORLANDC__
# define random(x) (rand()*(x)/(RAND_MAX+1)) // Winzigweich
#endif
void ZufallPuffer(NPVOID,LPWAVEHDR FAR*whp) {
static char buf[620]; // schön krumm zum Test
static WAVEHDR wh={buf,sizeof(buf),sizeof(buf)};
/* if (*whp) *whp=NULL; // im Wechsel: Puffer liefern und aussetzen (besser: FindTrigger hat TimeOut!!)
else*/{
LPSTR p=buf;
for (UINT i=0; i<elemof(buf)/2; i++) {
*p=(CHAR)(random(10)-5); p++; // nicht *p++ : dem Compiler leicht machen
*p=(char)(random(2)-28+rndint(50*sin((double)i/310*6.28))); p++;
}
*whp=&wh;
}
}
static INT_PTR CALLBACK ZufallDlgProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
// Eigentlich ein ganzer Mehrkanal-Funktionsgenerator, wenn's fertig ist!
Q_ZUFALL *q=(Q_ZUFALL*)GetWindowLongPtr(Wnd,DWLP_USER);
switch (Msg) {
case WM_INITDIALOG: {
// q=(Q_ZUFALL*)lParam;
SetWindowLongPtr(Wnd,DWLP_USER,lParam);
}return TRUE;
case WM_COMMAND: switch (LOWORD(wParam)) {
case IDOK: ;
}
}
DefDlgBottom(Wnd,Msg,wParam,lParam,&q->sd);
return FALSE;
}
bool Q_ZUFALL::RelayMsg(Q_MSG Msg,LPVOID lParam) {
switch (Msg) {
case Q_INIT: return QUELLE::RelayMsg(Msg,lParam);
case Q_GETSYSINFO: {
#define si ((LPSYSINFO)lParam)
if (!si) return false;
*(LPDWORD)si=MAKELONG(MAKEWORD(Q_SOFTTRIGGER|Q_CONTINUOUS|Q_ASYNC,8),
MAKEWORD(2,2));
si->rateminmax[0]=si->rateminmax[1]=10000;
si->depth=0;
si->getsample=GetCharSample;
si->blockalign=2;
#undef si
}return true;
case Q_SETUPDLG: {
sd.dlgProc=ZufallDlgProc;
sd.helpId=121;
}return QUELLE::RelayMsg(Msg,lParam);
case Q_GETCHANINFO: {
#define ci ((LPCHANINFO)lParam)
if (!ci) return false;
if (ci->ch>=2) return false;
ci->couplings=CHANINFO_DC;
ci->byteoffset=ci->ch;
ci->mask=0;
ci->voltminmax[0]=ci->voltminmax[1]=0.01F;
#undef ci
}return true;
case Q_SETCHAN: {
#define c ((LPCHAN)lParam)
if (!c) return false;
if (c->ch>=2) return false;
// if (c->what&CHAN_COUPLING && c->coupling!=CHAN_DC) return false;
c->coupling=CHAN_DC;
c->resistance=CHAN_R1M;
c->volt=0.01F;
c->dcoffset=0;
#undef c
}return true;
case Q_GETTRIGINFO: {
#define ti ((LPTRIGINFO)lParam)
if (!ti) return false;
*(LPDWORD)ti=MAKELONG(MAKEWORD(TRIGINFO_DC|TRIGINFO_AC,TRIGINFO_AC),
MAKEWORD(TRIGINFO_RISE|TRIGINFO_FALL,TRIGINFO_CHAN));
#undef ti
}return true;
case Q_SETTRIG: {
if (!QUELLE::RelayMsg(Msg,lParam)) return false;
#define t ((LPTRIG)lParam)
if (t->what&TRIG_SOURCE) {
if (t->source>=2) return false;
st.blockadd=t->source;
}
if (t->what&TRIG_PRE) st.pre=t->pre*2;
t->source=st.blockadd;
t->pre=st.pre/2;
#undef t
}return true;
case Q_ARM:
case Q_UNARM:
case Q_DONE: { QUELLE::RelayMsg(Msg,lParam); }break;
case Q_POLL: //return (bool)(QUELLE::RelayMsg(Msg,lParam)
// && FindTrigger(ZufallPuffer,this));
ZufallPuffer(this,&((LPWAVEHDR)lParam)->lpNext); break;
}
return true;
}
/******************************************************
** 2. Die ISA-Einsteckkarte als 2-Kanal-Oszilloskop **
******************************************************/
// Volt pro LSB für jede der 7 Verstärkungseinstellungen
static const float VoltList[7]={
(float)(0.05/32),
(float)(0.1/32),
(float)(0.2/32),
(float)(0.5/32),
(float)(1.0/32),
(float)(2.0/32),
(float)(5.0/32)};
int GetNearestVolt(float Wert, const float*Liste, int ListLen) {
float error=1E36F;
int i,j;
for (i=0; i<ListLen; i++,Liste++) {
float e=(float)fabs((Wert-*Liste)/ *Liste); // relative Abweichung
if (error>e) {error=e; j=i;} // Minimum: NICHT RICHTIG!!
}
return j;
}
static UINT PortBase=0x2C0;
static void access3(LPBYTE buf, UINT buflen, UINT start) {
WORD*p=(WORD*)buf;
UINT a=PortBase+2;
if (buflen) {
goto l1;
do{
if (LOBYTE(start)) outb(a,LOBYTE(start));
else l1: outw(a,start);
*p++=inw(a);
start++;
}while (--buflen);
}
}
static INT_PTR CALLBACK DSO220SetupDlgProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
// Die Portadresse ist ja noch festlegbar...
Q_DSO220 *qs=(Q_DSO220*)GetWindowLongPtr(Wnd,DWLP_USER);
switch (Msg) {
case WM_INITDIALOG: {
// qs=(Q_DSO220*)lParam;
SetWindowLongPtr(Wnd,DWLP_USER,lParam); // Q_DSO220 wegspeichern
UINT idx=(PortBase-0x280)>>3;
if (idx&~0xF) idx=0; // Außerhalb liegende Portadresse...???
CheckDlgButton(Wnd,100+idx,TRUE);
SetCheckboxGroup(Wnd,120,123,15-idx);
for (UINT i=100,p=0x280; i<116; i++,p+=8) {
TCHAR buf[32];
wsprintf(buf,T("%3Xh"),p);
SetDlgItemText(Wnd,i,buf); // Hexzahlen selber an die Radioknöpfe malen!?
}
}return TRUE;
case WM_COMMAND: switch (LOWORD(wParam)) {
case 120:
case 121:
case 122:
case 123: { // Markierfelder für gesetzte Jumper: Radioknöpfe nachführen
CheckRadioButton(Wnd,100,115,115-GetCheckboxGroup(Wnd,120,123));
}break;
case IDOK: {
TCHAR buf[32];
PortBase=(GetRadioCheck(Wnd,100,115)<<3)+0x280;
wsprintf(buf,T("0x%3X"),PortBase);
WriteString(T("DSO220"),T("Adresse"),buf);
}nobreak;
case IDCANCEL:
case IDHELP: break;
default: { // Radioknöpfe für Adressen: Markierfelder nachführen
SetCheckboxGroup(Wnd,120,123,15-GetRadioCheck(Wnd,100,115));
}
}
}
DefDlgBottom(Wnd,Msg,wParam,lParam,&qs->sd);
return FALSE;
}
void Q_DSO220::SetDSO() {
if (state&Q_ARMED) {
stop();
init(&ip);
outb(7,0);
start();
}
}
void DsoBlock(NPVOID p, LPWAVEHDR FAR*whp) {
static WAVEHDR wh={NULL,4000,4000};
if (*whp) { // Nur 1 Block
(*whp)->dwFlags|=WHDR_DONE;
return;
}
wh.lpData=(LPSTR)(((Q_DSO220*)p)->p);
access3((LPBYTE)wh.lpData,2000,0);
*whp=&wh;
}
bool Q_DSO220::RelayMsg(Q_MSG Msg,LPVOID lParam) {
switch (Msg) {
case Q_INIT: {
static INITPARAMS test={20000U,{{4,0},{4,0}},{2,0}};
TCHAR buf[32];
hPortTalk=INVALID_HANDLE_VALUE;
#ifdef WIN32
OSVERSIONINFO os; // Umstandskasten Win32
os.dwOSVersionInfoSize=sizeof(os);
if (GetVersionEx(&os) && os.dwPlatformId==VER_PLATFORM_WIN32_NT) {
#else
if (GetWinFlags() & WF_WINNT) {
#endif
hPortTalk=LoadLibrary(T("inpout32.dll"));
if (!hPortTalk) return false; // Kann erforderlichen Treiber nicht laden
}
GetString(T("DSO220"),T("Adresse"),T(""),buf,elemof(buf));
if (_stscanf(buf,T("%i"),&PortBase)!=1) { // hex. oder dez.!
DLGINFO di;
PortBase=0x280;
di.parent=MainWnd;
di.kbHand=NULL;
if (!RelayMsg(Q_SETUPDLG,&di)) return false; // Abbruch-Wunsch des Users
}
QUELLE::RelayMsg(Msg,lParam);
// EnablePorts(hPortTalk,PortBase,8); // bei NT wirksam
ip=test; // Struktur zum Start (Quatsch!)
st.mask=0x80; // Daten sind 80h-zentriert
}return true;
case Q_SETUPDLG: {
sd.dlgProc=DSO220SetupDlgProc;
sd.helpId=124;
}return QUELLE::RelayMsg(Msg,lParam);
case Q_GETSYSINFO: {
#define si ((LPSYSINFO)lParam)
if (!si) return false;
*(LPDWORD)si=MAKELONG(MAKEWORD(Q_SOFTTRIGGER|Q_ASYNC,8),MAKEWORD(2,3));
si->rateminmax[1]=20000000L;
si->rateminmax[0]=20000000L/65535;
si->depth=32768U;
si->getsample=GetCharSample;
si->blockalign=2;
#undef si
}return true;
case Q_GETCHANINFO: {
#define ci ((LPCHANINFO)lParam)
if (!ci) return false;
if (ci->ch>=2) return false;
ci->couplings=CHANINFO_DC|CHANINFO_AC|CHANINFO_CAL;
ci->byteoffset=(BYTE)(1-ci->ch); // hier Rückvertauschung vornehmen!
ci->mask=0x80; // (Kanäle ab sofort nicht mehr vertauscht!)
ci->voltminmax[0]=VoltList[0];
ci->voltminmax[1]=VoltList[6];
#undef ci
}return true;
case Q_SETCHAN: {
CHANNEL *channel;
#define c ((LPCHAN)lParam)
if (!c) return false;
if (c->ch>=2) return false;
channel=ip.channel+c->ch;
if (c->what&CHAN_COUPLING) {
if (c->coupling>=2) return false; // Kopplung wird nicht "gerundet"!
channel->coupling=c->coupling; // CHAN_DC(0) oder CHAN_AC(1)
}
if (c->what&CHAN_VOLT) { // Etwas anderes kann die Karte ja nicht!
channel->gain
=(BYTE)GetNearestVolt((float)fabs(c->volt),VoltList,elemof(VoltList));
}
if (c->what&(CHAN_COUPLING|CHAN_VOLT)) SetDSO();
c->coupling=channel->coupling;
c->resistance=CHAN_R1M;
c->volt=VoltList[channel->gain];
c->dcoffset=0;
#undef c
}return true;
case Q_GETTRIGINFO: {
#define ti ((LPTRIGINFO)lParam)
if (!ti) return false;
*(LPDWORD)ti=MAKELONG(MAKEWORD(TRIGINFO_DC|TRIGINFO_AC,TRIGINFO_AC),
MAKEWORD(TRIGINFO_RISE|TRIGINFO_FALL,TRIGINFO_CHAN));
#undef ti
}return true;
case Q_SETTRIG: {
if (!QUELLE::RelayMsg(Msg,lParam)) return false;
#define t ((LPTRIG)lParam)
if (t->what&TRIG_SOURCE) {
if (t->source>=3) return false;
ip.trigger.source=t->source;
if (ip.trigger.source==2) st.trigproc=ExtTrigger;
else{
st.trigproc=trcoupling?AcTrigger:DcTrigger;
st.blockadd=(BYTE)(1-t->source);
}
}
if (t->what&TRIG_PRE) st.pre=t->pre*2;
if (t->what&TRIG_EDGE) ip.trigger.edge=t->edge;
if (t->what&(TRIG_SOURCE|TRIG_EDGE)) SetDSO();
t->source=ip.trigger.source;
t->pre=ip.trigger.source<2?st.pre/2:0; // Bei "extern" kein Prätrigger
#undef t
}return true;
case Q_DONE: {
if (hPortTalk) {
// EnablePorts(hPortTalk,0,0);
CloseHandle(hPortTalk);
}
}break;
case Q_ARM: {
p=GlobalAlloc(LMEM_FIXED,4000); // Oh Gott, was für'n Kode!
QUELLE::RelayMsg(Msg,lParam);
init(&ip);
start();
}break;
case Q_UNARM: {
stop();
QUELLE::RelayMsg(Msg,lParam);
GlobalFree(p);
}break;
case Q_SETRATE: {
#define f ((LPFLOAT)lParam)
if (!f) return false;
if (*f>0) { // setzen
float samplediv=20E6F/ *f;
if (samplediv>65536L) samplediv=65536L;
WORD z=rndint(samplediv-1); // Runden lassen
if (ip.samplediv!=z) {
ip.samplediv=z;
SetDSO();
}
}
*f=20E6F/((long)ip.samplediv+1);
#undef f
}return true;
case Q_POLL: {
if (!QUELLE::RelayMsg(Msg,lParam)) return false;
#define wh ((LPWAVEHDR)lParam)
wh->lpNext=NULL; // Neuen Block ziehen (diskontinuierlich)
if ((UINT)inw(0)<2000) return false; // weiter wursteln
stop();
if (ip.trigger.source==2) wh->reserved=0;
// MessageBeep((UINT)-1);
DsoBlock(this,&wh->lpNext);
start(); // Quatsch!
#undef wh
}return true;
}
return false;
}
/***********************************
** 3. Soundkarte als Datenquelle **
***********************************/
static INT_PTR CALLBACK WaveInDlgProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
// Wenn "mal eben schnell" die richtige Soundkarte auszuwählen ist...
switch (Msg) {
case WM_INITDIALOG: {
UINT k=waveInGetNumDevs();
HWND w=GetDlgItem(Wnd,101);
SetWindowLongPtr(Wnd,DWLP_USER,lParam);
for (UINT i=0; i<k; i++) {
WAVEINCAPS wic;
waveInGetDevCaps(i,&wic,sizeof(wic));
ListBox_AddString(w,wic.szPname);
}
}return TRUE;
case WM_COMMAND: switch (LOWORD(wParam)) {
case IDOK: {
lParam=GetWindowLongPtr(Wnd,DWLP_USER);
int k=(int)SendDlgItemMessage(Wnd,101,LB_GETCURSEL,0,0);
if (k<0) break;
*(int*)lParam=k;
if (IsDlgButtonChecked(Wnd,102)) {
TCHAR buf[16];
wsprintf(buf,T("%d"),k);
WriteString(T("Soundkarte"),T("Nummer"),buf);
}
}nobreak;
case IDCANCEL: EndDialog(Wnd,wParam); break;
case IDHELP: WinHelp(Wnd,HelpFileName,HELP_CONTEXT,122);
}break;
}
return FALSE;
}
static INT_PTR CALLBACK WaveSetupDlgProc(HWND Wnd, UINT Msg, WPARAM wParam, LPARAM lParam) {
// "Kalibrierung" des Ablenkkoeffizienten (ist ja auch noch von den aktuellen
// Mixereinstellungen abhängig), sowie Angabe, ob die lästigen
// Eingangs-Kondensatoren schon ausgelötet sind...
Q_SOUND *qs=(Q_SOUND*)GetWindowLongPtr(Wnd,DWLP_USER);
switch (Msg) {
case WM_INITDIALOG: {
TCHAR buf[32];
qs=(Q_SOUND*)lParam;
SetWindowLongPtr(Wnd,DWLP_USER,lParam); // Q_SOUND wegspeichern
Float2String(buf,qs->lsb_volt,MAKEWORD(-2,0),T("V"));
SetDlgItemText(Wnd,101,buf);
CheckDlgButton(Wnd,102+qs->coupling,TRUE); // DC oder AC
// SendDlgItemMessage(Wnd,10,TBM_SETRANGE,FALSE,MAKELONG(0,65535));
}return TRUE;
#ifdef WIN32
case WM_HSCROLL: {/*switch (LOWORD(wParam)){ // vom TrackBar (Schieberegler)
case TB_THUMBTRACK: // Maus
case TB_ENDTRACK: { // Tastatur*/
UINT i=(UINT)SendMessage((HWND)lParam,TBM_GETPOS,0,0);
if (qs->hMixer && qs->dwLineID) {
MIXERCONTROLDETAILS_UNSIGNED val;
MIXERCONTROLDETAILS mcd;
mcd.cbStruct=sizeof(mcd);
mcd.dwControlID=qs->dwControlID; // Schon eindeutig?
mcd.cChannels=1; // alle Kanäle
mcd.cMultipleItems=0;
mcd.cbDetails=sizeof(val);
mcd.paDetails=&val;
val.dwValue=MulDiv(i,65535,100);
mixerSetControlDetails((HMIXEROBJ)qs->hMixer,&mcd,MIXER_SETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
}
// _asm int 3;
// }break;
}break;
#endif
case WM_COMMAND: switch (LOWORD(wParam)) {
case IDOK: {
TCHAR buf[32],e[ELEN];
GetDlgItemText(Wnd,101,buf,elemof(buf));
if (!String2Float(buf,qs->lsb_volt,e)) {
SetEditFocus(Wnd,101);
MBox(Wnd,201,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}
qs->coupling=(BYTE)IsDlgButtonChecked(Wnd,103);
WriteString(T("Soundkarte"),T("VoltProLsb"),buf);
WriteString(T("Soundkarte"),T("Kopplung"),qs->coupling?T("AC"):T("DC"));
#ifdef WIN32
_sntprintf(buf,elemof(buf),T("%i"),SendDlgItemMessage(Wnd,10,TBM_GETPOS,0,0));
WriteString(T("Soundkarte"),T("Mixer"),buf);
#endif
}break;
}
}
DefDlgBottom(Wnd,Msg,wParam,lParam,&qs->sd);
return FALSE;
}
MMRESULT Q_SOUND::WaveOpen() {
// Samplerate, Kanalzahl, ByteProSample sind bereits gesetzt,
// die übrigen Felder werden "nachgerechnet"
if (handle) {waveInClose(handle); handle=0;}
wf.wFormatTag=WAVE_FORMAT_PCM;
wf.wBitsPerSample=(WORD)(1<<(byteshift+3));
wf.nBlockAlign=(WORD)(wf.nChannels<<byteshift);
wf.nAvgBytesPerSec=wf.nSamplesPerSec*wf.nBlockAlign;
wf.cbSize=0;
return waveInOpen(&handle,DevID,&wf,(UINT)MainWnd,0,CALLBACK_WINDOW);
} // der (DWORD)-Cast produziert bei STRICT ein "push ds"!
// Ermittelt die nächstliegende gängige Samplerate
MMRESULT Q_SOUND::NearestRate(DWORD rate) {
// Lt. Dr.Kakuschke unterstützen Soundkarten bis zu 96 kSa/s,
// vielleicht auch noch mehr Kanäle, auch bei Aufnahme?
static DWORD Rates[]={96000L,48000L,44100L,22050L,11025L,8000L,4000L,2000L,1000L};
int i;
DWORD oldrate=wf.nSamplesPerSec; // Retten zum Vergleich
// ...dem Spuk idiotischer Soundkarten-Treiber eine Grenze setzen!
// Auch in mittelferner Zukunft wird es keine Soundkarten mit mehr als 1 MSa/s
// geben. Aber die "Avance AC97 Audio" spinnt unter Win9x gewaltig!
if (bekloppt) {
if (rate>44100U) rate=44100U; // stärker einschränken!
if (rate<11025U) rate=11025U;
}
wf.nSamplesPerSec=rate; // Erst mal direkt probieren
if (!WaveOpen()) {
if (rate==1000000L) bekloppt=true;
else{
if (MinRate>rate) MinRate=rate;
if (MaxRate<rate) MaxRate=rate;
}return 0; // Treiber == Allesfresser!
}
if (rate>MaxRate) { wf.nSamplesPerSec=MaxRate; if (!WaveOpen()) return 0;}
if (rate<MinRate) { wf.nSamplesPerSec=MinRate; if (!WaveOpen()) return 0;}
for (i=elemof(Rates); --i>=0;) if (Rates[i]>rate) {
wf.nSamplesPerSec=Rates[i]; // Nur die größeren probieren, erst mal
if (!WaveOpen()) return 0;
}
for (i=0; i<elemof(Rates); i++) if (Rates[i]<rate) {
wf.nSamplesPerSec=Rates[i]; // Jetzt die kleineren probieren
if (!WaveOpen()) return 0;
}
wf.nSamplesPerSec=oldrate; // Wenn nichts mehr hilft, unverändert lassen
return WaveOpen();
}
// Probiert für gegebene Samplerate und Bits die Anzahl verfügbarer Kanäle durch
void Q_SOUND::MaxChannels() {
for (int i=8; i; i-=2) { // 8, 6, 4, 2 ausprobieren
wf.nChannels=(WORD)i;
if (!WaveOpen()) return;
}
wf.nChannels=1; // sonst nur 1 Kanal
WaveOpen();
}
// Probiert für gefundene Kanalzahl die Bitbreite (8 oder 16) durch
void Q_SOUND::MaxBits() {
byteshift=1; // 16 bit
if (!WaveOpen()) return;
byteshift--; // 0 = 8 bit
}
void Q_SOUND::NextWaveHdr(LPWAVEHDR FAR&whp) {
if (whp) {
whp->dwFlags&=~WHDR_DONE;
waveInAddBuffer(handle,whp,sizeof(WAVEHDR));
}
whp=NULL;
if (wh[currentblock].dwFlags&WHDR_DONE) {
whp=wh+currentblock;
currentblock++; if (currentblock==elemof(wh)) currentblock=0;
}
}
#ifdef WIN32
void ListLineControls(HMIXER hMixer,UINT LineID,UINT cControls) {
MIXERCONTROL *mc=new MIXERCONTROL[cControls];
MIXERLINECONTROLS mlc;
mlc.cbStruct=sizeof(mlc);
mlc.cControls=cControls;
mlc.dwLineID=LineID;
mlc.dwControlType=0;
mlc.cbmxctrl=sizeof(MIXERCONTROL);
mlc.pamxctrl=mc;
mixerGetLineControls((HMIXEROBJ)hMixer,&mlc,MIXER_GETLINECONTROLSF_ALL|MIXER_OBJECTF_HMIXER);
TCHAR s[1024],*p=s;
for (UINT i=0; i<cControls; i++) {
TCHAR typ[64],*ptyp=typ;
wsprintf(typ,T("%X"),mc[i].dwControlType);
switch (mc[i].dwControlType) {
case MIXERCONTROL_CONTROLTYPE_VOLUME: ptyp=T("MIXERCONTROL_CONTROLTYPE_VOLUME"); break;
case MIXERCONTROL_CONTROLTYPE_MIXER: ptyp=T("MIXERCONTROL_CONTROLTYPE_MIXER"); break;
case MIXERCONTROL_CONTROLTYPE_MUX: ptyp=T("MIXERCONTROL_CONTROLTYPE_MUX"); break;
}
p+=wsprintf(p,T("%s,%s,%s,%X,%d,(%d,%d),(%d,%d)"),
mc[i].szName,mc[i].szShortName,ptyp,mc[i].fdwControl,mc[i].cMultipleItems,
#ifdef __BORLANDC__
mc[i].Bounds.dwReserved[0],mc[i].Bounds.dwReserved[1],
#else
mc[i].Bounds.lMinimum,mc[i].Bounds.lMaximum,
#endif
mc[i].Metrics.cSteps,mc[i].Metrics.cbCustomData);
/*if (typ!=ptyp)*/ {
int j=1; if (mc[i].fdwControl&MIXERCONTROL_CONTROLF_MULTIPLE) j=mc[i].cMultipleItems;
PMIXERCONTROLDETAILS_UNSIGNED val=new MIXERCONTROLDETAILS_UNSIGNED[j];
MIXERCONTROLDETAILS mcd;
mcd.cbStruct=sizeof(mcd);
mcd.dwControlID=mc[i].dwControlID; // Schon eindeutig?
mcd.cChannels=1; // alle Kanäle
mcd.cMultipleItems=mc[i].cMultipleItems;
mcd.cbDetails=sizeof(val); // Hä?
mcd.paDetails=val;
mixerGetControlDetails((HMIXEROBJ)hMixer,&mcd,MIXER_GETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
for (int i=0; i<j; i++) {
p+=wsprintf(p,T(",%u"),val[i].dwValue); // Lautstärke?
}
}
p+=wsprintf(p,T("\n"));
}
delete[] mc;
if (cControls) MessageBox(MainWnd,s,T("LineControls"),0);
}
#endif
/*
void NextWaveHdr(NPVOID p, LPWAVEHDR FAR*whp) {
((Q_SOUND*)p)->NextWaveHdr(*whp); // Memberfunktionsaufruf
}
*/
bool Q_SOUND::RelayMsg(Q_MSG Msg,LPVOID lParam) {
switch (Msg) {
case Q_INIT: {
QUELLE::RelayMsg(Msg,lParam);
switch (waveInGetNumDevs()) {
case 0: return false; // Keine WaveIn-Geräte
case 1: DevID=0; break; // ein Gerät: alles klar
default: {
DevID=GetInt(T("Soundkarte"),T("Nummer"),-1);
if ((int)DevID<0 && DialogBoxParam(HInstance,MAKEINTRESOURCE(122),MainWnd,
WaveInDlgProc,(LPARAM)&DevID)!=IDOK) return false;
}
}
handle=0;
byteshift=1;
bekloppt=false;
wf.nSamplesPerSec=22050;
MaxChannels();
if (!handle) {
byteshift--;
MaxChannels();
}
MaxBits();
NearestRate(1000L);
MinRate=wf.nSamplesPerSec; // Minimale Samplerate merken
UINT e=NearestRate(1000000L);
MaxRate=wf.nSamplesPerSec; // Maximale Samplerate merken
if (e) {
TCHAR msg[200];
waveInGetErrorText(e,msg,elemof(msg));
MBox(MainWnd,222,MB_OK,(LPCTSTR)msg);
break;
}
#ifdef WIN32
hMixer=0; dwLineID=0;
DWORD cControls;
mixerOpen(&hMixer,(UINT)handle,(UINT)MainWnd,0,CALLBACK_WINDOW|MIXER_OBJECTF_HWAVEIN);
if (hMixer) {
MIXERCAPS mc;
mixerGetDevCaps((UINT)hMixer,&mc,sizeof(mc));
for (UINT i=0; i<mc.cDestinations; i++) {
MIXERLINE ml;
ml.cbStruct=sizeof(ml);
ml.dwDestination=i;
mixerGetLineInfo((HMIXEROBJ)hMixer,&ml,MIXER_GETLINEINFOF_DESTINATION|MIXER_OBJECTF_HMIXER);
if (ml.dwComponentType==MIXERLINE_COMPONENTTYPE_DST_WAVEIN) {
ListLineControls(hMixer,ml.dwLineID,ml.cControls);
for (UINT i=0; i<ml.cConnections; i++) {
MIXERLINE ml2;
ml2.cbStruct=sizeof(ml2);
ml2.dwDestination=ml.dwDestination;
ml2.dwSource=i;
mixerGetLineInfo((HMIXEROBJ)hMixer,&ml2,MIXER_GETLINEINFOF_SOURCE|MIXER_OBJECTF_HMIXER);
if (ml2.dwComponentType==MIXERLINE_COMPONENTTYPE_SRC_AUXILIARY
|| ml2.dwComponentType==MIXERLINE_COMPONENTTYPE_SRC_LINE) {
cControls=ml2.cControls;
dwLineID=ml2.dwLineID; // Gefunden!!
break;
}
}
}
}
if (dwLineID) {
ListLineControls(hMixer,dwLineID,cControls);
MIXERCONTROL mc;
MIXERLINECONTROLS mlc;
mlc.cbStruct=sizeof(mlc);
mlc.cControls=1;
mlc.dwLineID=dwLineID; // Gefundene ID
mlc.dwControlType=MIXERCONTROL_CONTROLTYPE_VOLUME;
mlc.cbmxctrl=sizeof(MIXERCONTROL);
mlc.pamxctrl=&mc;
mixerGetLineControls((HMIXEROBJ)hMixer,&mlc,MIXER_GETLINECONTROLSF_ONEBYTYPE|MIXER_OBJECTF_HMIXER);
dwControlID=mc.dwControlID;
MIXERCONTROLDETAILS_UNSIGNED val;
MIXERCONTROLDETAILS mcd;
mcd.cbStruct=sizeof(mcd);
mcd.dwControlID=dwControlID; // Schon eindeutig?
mcd.cChannels=1; // alle Kanäle
mcd.cMultipleItems=0;
mcd.cbDetails=sizeof(val);
mcd.paDetails=&val;
mixerGetControlDetails((HMIXEROBJ)hMixer,&mcd,MIXER_GETCONTROLDETAILSF_VALUE|MIXER_OBJECTF_HMIXER);
}
}
#endif
lsb_volt= byteshift ? 1E-4F : 1E-2F;
coupling=CHAN_AC;
{
TCHAR buf[32],e[ELEN];
Float2String(buf,lsb_volt,MAKEWORD(-2,0),T("V"));
GetString(T("Soundkarte"),T("VoltProLsb"),buf,buf,elemof(buf));
String2Float(buf,lsb_volt,e);
GetString(T("Soundkarte"),T("Kopplung"),T("AC"),buf,elemof(buf));
if (!lstrcmpi(buf,T("DC"))) coupling=CHAN_DC;
#ifdef WIN32
GetString(T("Soundkarte"),T("Mixer"),buf,buf,elemof(buf));
#endif
}
st.mask=0x80; // wird bei 16bit (noch) nicht ausgewertet
st.blockalign=wf.nBlockAlign;
st.min= byteshift ?-0x8000 :-0x80;
st.max= byteshift ? 0x7FFF : 0x7F;
}return true;
case Q_SETUPDLG: {
sd.dlgProc=WaveSetupDlgProc;
sd.helpId=123;
}return QUELLE::RelayMsg(Msg,lParam);
case Q_GETSYSINFO: {
#define si ((LPSYSINFO)lParam)
if (!si) return false;
si->flags=Q_SOFTTRIGGER|Q_CONTINUOUS;
si->bits=(BYTE)wf.wBitsPerSample;
si->numchan=si->numtrig=(BYTE)wf.nChannels;
si->rateminmax[0]=(float)MinRate;
si->rateminmax[1]=(float)MaxRate;
si->depth=0; // unendlich
si->getsample=byteshift?GetShortSample:GetCharSample;
si->blockalign=wf.nBlockAlign;
#undef si
}return true;
case Q_GETCHANINFO: {
#define ci ((LPCHANINFO)lParam)
if (!ci) return false; // NULL-Zeiger
if (ci->ch>=wf.nChannels) return false;
ci->couplings=(BYTE)(coupling ? CHANINFO_AC : CHANINFO_DC);
ci->byteoffset=(BYTE)(ci->ch<<byteshift);
ci->mask=0x80; // wird bei GetShortSample nicht ausgewertet
ci->voltminmax[0]=ci->voltminmax[1]=lsb_volt;
#undef ci
}return true;
case Q_SETCHAN: {
#define c ((LPCHAN)lParam)
if (!c) return false;
if (c->ch>=wf.nChannels) return false;
// if (c->what&CHAN_COUPLING && c->coupling==CHAN_DC) return false;
c->coupling=coupling;
c->resistance=CHAN_R1M;
c->volt=lsb_volt;
c->dcoffset=0;
#undef c
}return true;
case Q_GETTRIGINFO: {
#define ti ((LPTRIGINFO)lParam)
if (!ti) return false;
*(LPDWORD)ti=MAKELONG(MAKEWORD(TRIGINFO_AC,0),
MAKEWORD(TRIGINFO_RISE|TRIGINFO_FALL,TRIGINFO_CHAN));
if (coupling==CHAN_DC) ti->couplings=TRIGINFO_DC|TRIGINFO_AC;
#undef ti // bei kontinuierlicher Quelle Sache der Software!
}return true;
case Q_SETTRIG: {
if (!QUELLE::RelayMsg(Msg,lParam)) return false;
#define t ((LPTRIG)lParam)
if (t->what&TRIG_SOURCE) {
if (t->source>=wf.nChannels) return false;
st.blockadd=(BYTE)(t->source<<byteshift);
}
if (t->what&TRIG_PRE) st.pre=t->pre*wf.nBlockAlign;
t->source=(BYTE)(st.blockadd>>byteshift);
t->pre=st.pre/wf.nBlockAlign;
#undef t
}return true;
case Q_SETRATE: {
#define f ((LPFLOAT)lParam)
if (!f) return false;
if (*f>0) {
BYTE st=state;
if (st&Q_ARMED) RelayMsg(Q_UNARM,0);
if (!NearestRate(rndint(*f))) { // Runden lassen
if (st&Q_ARMED) RelayMsg(Q_ARM,0);
}else{
MessageBeep((UINT)-1); // Einzige Ursache: Ressource geklaut?
return false;
}
}
*f=(float)wf.nSamplesPerSec; // Samplerate ist umstellbar!
#undef f
}return true;
case Q_ARM: {
if (!handle) break;
// filled_to=buffer;
if (state&Q_ARMED) break;
for (int i=0; i<elemof(wh); i++) {
wh[i].lpData=(LPSTR)/*GlobalLock(hb[i]);*/
/*hb[i]=*/GlobalAlloc(/*GMEM_MOVEABLE*/GMEM_FIXED|GMEM_SHARE,2048);
wh[i].dwBufferLength=2048;
wh[i].dwFlags=0;
waveInPrepareHeader(handle,wh+i,sizeof(WAVEHDR));
waveInAddBuffer(handle,wh+i,sizeof(WAVEHDR));
}
currentblock=0;
waveInStart(handle);
state|=Q_ARMED;
}break;
case Q_UNARM: {
if (!handle) break;
if (!(state&Q_ARMED)) break;
state&=(BYTE)~Q_ARMED;
waveInReset(handle);
for (int i=0; i<elemof(wh); i++) {
waveInUnprepareHeader(handle,wh+i,sizeof(WAVEHDR));
// GlobalUnlock(hb[i]);
GlobalFree(/*hb*/wh[i].lpData);
}
WaveHdr.lpNext=NULL; // Zeiger gilt nicht mehr
}break;
case Q_DONE: {
RelayMsg(Q_UNARM,0); // idiotensicher!
#ifdef WIN32
if (hMixer) mixerClose(hMixer);
#endif
if (!handle) break;
waveInClose(handle);
}break;
case Q_POLL: // Nächsten Waveform-Block bereitstellen
NextWaveHdr(((LPWAVEHDR)lParam)->lpNext); break;
/* TRACKBAR_CLASS
for (;;) {
LPSTR p=w->lpData; // eigentlich LPVOID, aber MSVC stellt sich blöd
// hier: pos=SucheTrigger(p,w->dwBytesRecorded)
// Bei pos=-1 (nicht gefunden) muss nur der Prätrigger-Anteil
// (-tr.post) vom Ende her gespeichert werden.
while (w->dwBytesRecorded) {
UINT platz=(UINT)buffer_end-(UINT)filled_to; // Bytes
if (platz>w->dwBytesRecorded) platz=(UINT)w->dwBytesRecorded;
CopyMemory(filled_to,p,platz);
filled_to+=platz; if (filled_to==buffer_end) filled_to=buffer;
p+=platz;
w->dwBytesRecorded-=platz; // verbleibende Bytes
}
waveInAddBuffer(handle,w,sizeof(WAVEHDR));
currentblock++; if (currentblock==elemof(wh)) currentblock=0;
}*/
}
return false;
}
| Detected encoding: ANSI (CP1252) | 4
|
|
|