winmm.c.bak

This is a futaba PCM decode source. You can study futaba pcm code.

    void (*waveInGetDevCapsA)(void);
    void (*waveInGetDevCapsW)(void);
    void (*waveInGetErrorTextA)(void);
    void (*waveInGetErrorTextW)(void);
    void (*waveInGetID)(void);
    void (*waveInGetNumDevs)(void);
    void (*waveInGetPosition)(void);
    void (*waveInMessage)(void);
//    void (*waveInOpen)(void);
    UINT WINAPI (*waveInOpen)(void*, UINT, void*, DWORD, DWORD, DWORD);
//    void (*waveInPrepareHeader)(void);
    UINT WINAPI (*waveInPrepareHeader)(HWAVEIN, void*, UINT);
//    void (*waveInReset)(void);
    UINT WINAPI (*waveInReset)(HWAVEIN);
//    void (*waveInStart)(void);
    UINT WINAPI (*waveInStart)(HWAVEIN);
//    void (*waveInStop)(void);
    UINT WINAPI (*waveInStop)(HWAVEIN);
//    void (*waveInUnprepareHeader)(void);
    UINT WINAPI (*waveInUnprepareHeader)(HWAVEIN, void*, UINT);
    void (*waveOutBreakLoop)(void);
    void (*waveOutClose)(void);
    void (*waveOutGetDevCapsA)(void);
    void (*waveOutGetDevCapsW)(void);
    void (*waveOutGetErrorTextA)(void);
    void (*waveOutGetErrorTextW)(void);
    void (*waveOutGetID)(void);
    void (*waveOutGetNumDevs)(void);
    void (*waveOutGetPitch)(void);
    void (*waveOutGetPlaybackRate)(void);
    void (*waveOutGetPosition)(void);
    void (*waveOutGetVolume)(void);
    void (*waveOutMessage)(void);
    void (*waveOutOpen)(void);
    void (*waveOutPause)(void);
    void (*waveOutPrepareHeader)(void);
    void (*waveOutReset)(void);
    void (*waveOutRestart)(void);
    void (*waveOutSetPitch)(void);
    void (*waveOutSetPlaybackRate)(void);
    void (*waveOutSetVolume)(void);
    void (*waveOutUnprepareHeader)(void);
    void (*waveOutWrite)(void);
    void (*wid32Message)(void);
    void (*winmmDbgOut)(void);
    void (*winmmSetDebugLevel)(void);
    void (*wod32Message)(void);
} winmm;

//---------------------------------------------------------------------------
static HWAVEIN       waveIn;         // WAVE OUT僴儞僪儖
static WAVEFORMATEX  waveFmt;
static WAVEHDR      *waveBuf[2];      // WAVEHDR峔憿懱傊偺億僀儞僞
static volatile BOOL waveRecording;
static const int     waveBufSize = 1024;
static int Position[6];
//---------------------------------------------------------------------------

#ifdef JR_PCM
static void __fastcall ProcessPulse(int width, BOOL input)
{
    static int sync = 0;

    static unsigned int bitcount = 0;
    static unsigned int bitstream = 0;
    static int data[30];
    static int datacount = 0;

    if (sync == 0 && (int)floor(2.0 * width / PW_JR + 0.5) == 5) {
        sync = 1;
        bitstream = 0;
        bitcount = -1;
        datacount = 0;
        return;
    }

    if (!sync) return;

    width = (int)floor((double)width / PW_JR + 0.5);
    bitstream = ((bitstream << 1) + 1) << (width - 1);
    bitcount += width;

    if (bitcount >= 8) {
        bitcount -= 8;
        if ((data[datacount++] = jr_symbol[(bitstream >> bitcount) & 0xFF]) < 0) {
            sync = 0;
            return;
        }
    }

    switch (datacount) {
        case 3:  Position[2] = 1023 - ((data[1] << 5) | data[2]); break;
        case 6:  Position[0] = 1023 - ((data[4] << 5) | data[5]); break;
        case 11: Position[5] = 1023 - ((data[9] << 5) | data[10]); break;
        case 14: break;
        case 18: Position[3] = 1023 - ((data[16] << 5) | data[17]); break;
        case 21: Position[1] = 1023 - ((data[19] << 5) | data[20]); break;
        case 26: Position[4] = 1023 - ((data[24] << 5) | data[25]); break;
        case 28: break;
        case 30: sync = 0;
    }
}
#endif

//---------------------------------------------------------------------------

#ifdef FUTABA_PCM
static void __fastcall ProcessPulse(int width, BOOL input)
{
    static int sync = 0;

    static unsigned int bit = 0;
    static unsigned int bitcount = 0;
    static unsigned int bitstream = 0;

    static int data[32];
    static int datacount = 0;

    width = (int)floor(width / PW_FUTABA + 0.5);

    if (sync == 0 && width == 18) {
        sync = 1;
        bit = 0;
        bitstream = 0;
        bitcount = 0;
        datacount = 0;
        return;
    }

    if (!sync) return;

    bitstream = (bitstream << width) | (bit >> (32 - width));
    bit ^= 0xFFFFFFFF;
    bitcount += width;

    if (sync == 1) {
        if (bitcount >= 6) {
            bitcount -= 6;
            if (((bitstream >> bitcount) & 0x3F) == 0x03) {
                sync = 2;
                datacount = 0;
            } else if (((bitstream >> bitcount) & 0x3F) == 0x00) {
                sync = 2;
                datacount = 16;
                bitcount -= 2;
            } else {
                sync = 0;
            }
        }
        return;
    }

    if (bitcount >= 10) {
        bitcount -= 10;
        if ((data[datacount++] = futaba_symbol[(bitstream >> bitcount) & 0x3FF]) < 0) {
            sync = 0;
            return;
        }
    }

    switch (datacount) {
        case 3:  if ((data[0] >> 4) != 0)  Position[2] = (data[1] << 4) | (data[2] >> 2); break;
        case 7:                            Position[3] = (data[5] << 4) | (data[6] >> 2); break;
        case 11: if ((data[0] >> 4) != 0)  Position[4] = (data[9] << 4) | (data[10] >> 2); break;
        case 15: sync = 0;
        case 19:                           Position[1] = (data[17] << 4) | (data[18] >> 2); break;
        case 23: if ((data[16] >> 4) != 1) Position[0] = (data[21] << 4) | (data[22] >> 2); break;
        case 27:                           Position[5] = (data[25] << 4) | (data[26] >> 2); break;
        case 31: break;
        case 32: sync = 0;
    }
}
//---------------------------------------------------------------------------
#endif

#ifdef FUTABA_PPM
static void __fastcall ProcessPulse(int width, BOOL input)
{
    static int sync = 0;

    int newdata;
    static int data[14];
    static int datacount = 0;

    if (sync == 0 && width > PPM_TRIG) {
        sync = 1;
        datacount = 0;
    }

    if (!sync) return;

    newdata = (width - PPM_MIN) / (PPM_MAX - PPM_MIN) * 1024;
    if (newdata < 0) newdata = 0;
    else if (newdata > 1023) newdata = 1023;

    if (data[datacount] - newdata > 100) data[datacount] -= 100;
    else if (newdata - data[datacount] > 100) data[datacount] += 100;
    else data[datacount] = (data[datacount] + newdata) / 2;
    datacount++;

    switch (datacount) {
        case 3:  Position[2] = data[2]; break;
        case 5:  Position[1] = data[4]; break;
        case 7:  Position[3] = data[6]; break;
        case 9:  Position[0] = data[8]; break;
        case 11: Position[4] = data[10]; break;
        case 13: Position[5] = data[12]; sync = 0; break;
    }
}
#endif

#ifdef JR_PPM
static void __fastcall ProcessPulse(int width, BOOL input)
{
    static int sync = 0;

    int newdata;
    static int data[14];
    static int datacount = 0;

    if (sync == 0 && width > PPM_TRIG) {
        sync = 1;
        datacount = 0;
    }